/**************************************************
beginning of licensing agreement
Microsoft Public License (Ms-PL)

This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.

1. Definitions

The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under U.S. copyright law.

A "contribution" is the original software, or any additions or changes to the software.

A "contributor" is any person that distributes its contribution under this license.

"Licensed patents" are a contributor's patent claims that read directly on its contribution.

2. Grant of Rights

(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.

(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.

3. Conditions and Limitations

(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.

(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically.

(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.

(D) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license.

(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement. 
end of licensing agreement
**************************************************/
//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.2032
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

// 
// This source code was auto-generated by xsd, Version=1.1.4322.2032.
// 
namespace PssdiagSchema.Namespace {
    using System;
    using System.Data;
    using System.Xml;
    using System.Runtime.Serialization;
    
    
    [Serializable()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Diagnostics.DebuggerStepThrough()]
    [System.ComponentModel.ToolboxItem(true)]
    public class NewDataSet : DataSet {
        
        private CollectionDataTable tableCollection;
        
        private MachinesDataTable tableMachines;
        
        private MachineDataTable tableMachine;
        
        private MachineCollectorsDataTable tableMachineCollectors;
        
        private EventlogCollectorDataTable tableEventlogCollector;
        
        private PerfmonCollectorDataTable tablePerfmonCollector;
        
        private PerfmonCountersDataTable tablePerfmonCounters;
        
        private PerfmonObjectDataTable tablePerfmonObject;
        
        private PerfmonCounterDataTable tablePerfmonCounter;
        
        private MachineCollectorDataTable tableMachineCollector;
        
        private InstancesDataTable tableInstances;
        
        private InstanceDataTable tableInstance;
        
        private CollectorsDataTable tableCollectors;
        
        private SqldiagCollectorDataTable tableSqldiagCollector;
        
        private BlockingCollectorDataTable tableBlockingCollector;
        
        private ProfilerCollectorDataTable tableProfilerCollector;
        
        private EventsDataTable tableEvents;
        
        private EventTypeDataTable tableEventType;
        
        private EventDataTable tableEvent;
        
        private CollectorDataTable tableCollector;
        
        private CustomDiagGroupDataTable tableCustomDiagGroup;
        
        private DataRelation relationPerfmonObject_PerfmonCounter;
        
        private DataRelation relationPerfmonCounters_PerfmonObject;
        
        private DataRelation relationPerfmonCollector_PerfmonCounters;
        
        private DataRelation relationMachineCollectors_EventlogCollector;
        
        private DataRelation relationMachineCollectors_PerfmonCollector;
        
        private DataRelation relationMachineCollectors_MachineCollector;
        
        private DataRelation relationEventType_Event;
        
        private DataRelation relationEvents_EventType;
        
        private DataRelation relationProfilerCollector_Events;
        
        private DataRelation relationCollectors_SqldiagCollector;
        
        private DataRelation relationCollectors_BlockingCollector;
        
        private DataRelation relationCollectors_ProfilerCollector;
        
        private DataRelation relationCollectors_Collector;
        
        private DataRelation relationCollectors_CustomDiagGroup;
        
        private DataRelation relationInstance_Collectors;
        
        private DataRelation relationInstances_Instance;
        
        private DataRelation relationMachine_MachineCollectors;
        
        private DataRelation relationMachine_Instances;
        
        private DataRelation relationMachines_Machine;
        
        private DataRelation relationCollection_Machines;
        
        public NewDataSet() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        protected NewDataSet(SerializationInfo info, StreamingContext context) {
            string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
            if ((strSchema != null)) {
                DataSet ds = new DataSet();
                ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
                if ((ds.Tables["Collection"] != null)) {
                    this.Tables.Add(new CollectionDataTable(ds.Tables["Collection"]));
                }
                if ((ds.Tables["Machines"] != null)) {
                    this.Tables.Add(new MachinesDataTable(ds.Tables["Machines"]));
                }
                if ((ds.Tables["Machine"] != null)) {
                    this.Tables.Add(new MachineDataTable(ds.Tables["Machine"]));
                }
                if ((ds.Tables["MachineCollectors"] != null)) {
                    this.Tables.Add(new MachineCollectorsDataTable(ds.Tables["MachineCollectors"]));
                }
                if ((ds.Tables["EventlogCollector"] != null)) {
                    this.Tables.Add(new EventlogCollectorDataTable(ds.Tables["EventlogCollector"]));
                }
                if ((ds.Tables["PerfmonCollector"] != null)) {
                    this.Tables.Add(new PerfmonCollectorDataTable(ds.Tables["PerfmonCollector"]));
                }
                if ((ds.Tables["PerfmonCounters"] != null)) {
                    this.Tables.Add(new PerfmonCountersDataTable(ds.Tables["PerfmonCounters"]));
                }
                if ((ds.Tables["PerfmonObject"] != null)) {
                    this.Tables.Add(new PerfmonObjectDataTable(ds.Tables["PerfmonObject"]));
                }
                if ((ds.Tables["PerfmonCounter"] != null)) {
                    this.Tables.Add(new PerfmonCounterDataTable(ds.Tables["PerfmonCounter"]));
                }
                if ((ds.Tables["MachineCollector"] != null)) {
                    this.Tables.Add(new MachineCollectorDataTable(ds.Tables["MachineCollector"]));
                }
                if ((ds.Tables["Instances"] != null)) {
                    this.Tables.Add(new InstancesDataTable(ds.Tables["Instances"]));
                }
                if ((ds.Tables["Instance"] != null)) {
                    this.Tables.Add(new InstanceDataTable(ds.Tables["Instance"]));
                }
                if ((ds.Tables["Collectors"] != null)) {
                    this.Tables.Add(new CollectorsDataTable(ds.Tables["Collectors"]));
                }
                if ((ds.Tables["SqldiagCollector"] != null)) {
                    this.Tables.Add(new SqldiagCollectorDataTable(ds.Tables["SqldiagCollector"]));
                }
                if ((ds.Tables["BlockingCollector"] != null)) {
                    this.Tables.Add(new BlockingCollectorDataTable(ds.Tables["BlockingCollector"]));
                }
                if ((ds.Tables["ProfilerCollector"] != null)) {
                    this.Tables.Add(new ProfilerCollectorDataTable(ds.Tables["ProfilerCollector"]));
                }
                if ((ds.Tables["Events"] != null)) {
                    this.Tables.Add(new EventsDataTable(ds.Tables["Events"]));
                }
                if ((ds.Tables["EventType"] != null)) {
                    this.Tables.Add(new EventTypeDataTable(ds.Tables["EventType"]));
                }
                if ((ds.Tables["Event"] != null)) {
                    this.Tables.Add(new EventDataTable(ds.Tables["Event"]));
                }
                if ((ds.Tables["Collector"] != null)) {
                    this.Tables.Add(new CollectorDataTable(ds.Tables["Collector"]));
                }
                if ((ds.Tables["CustomDiagGroup"] != null)) {
                    this.Tables.Add(new CustomDiagGroupDataTable(ds.Tables["CustomDiagGroup"]));
                }
                this.DataSetName = ds.DataSetName;
                this.Prefix = ds.Prefix;
                this.Namespace = ds.Namespace;
                this.Locale = ds.Locale;
                this.CaseSensitive = ds.CaseSensitive;
                this.EnforceConstraints = ds.EnforceConstraints;
                this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
                this.InitVars();
            }
            else {
                this.InitClass();
            }
            this.GetSerializationData(info, context);
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public CollectionDataTable Collection {
            get {
                return this.tableCollection;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public MachinesDataTable Machines {
            get {
                return this.tableMachines;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public MachineDataTable Machine {
            get {
                return this.tableMachine;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public MachineCollectorsDataTable MachineCollectors {
            get {
                return this.tableMachineCollectors;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public EventlogCollectorDataTable EventlogCollector {
            get {
                return this.tableEventlogCollector;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public PerfmonCollectorDataTable PerfmonCollector {
            get {
                return this.tablePerfmonCollector;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public PerfmonCountersDataTable PerfmonCounters {
            get {
                return this.tablePerfmonCounters;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public PerfmonObjectDataTable PerfmonObject {
            get {
                return this.tablePerfmonObject;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public PerfmonCounterDataTable PerfmonCounter {
            get {
                return this.tablePerfmonCounter;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public MachineCollectorDataTable MachineCollector {
            get {
                return this.tableMachineCollector;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public InstancesDataTable Instances {
            get {
                return this.tableInstances;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public InstanceDataTable Instance {
            get {
                return this.tableInstance;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public CollectorsDataTable Collectors {
            get {
                return this.tableCollectors;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public SqldiagCollectorDataTable SqldiagCollector {
            get {
                return this.tableSqldiagCollector;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public BlockingCollectorDataTable BlockingCollector {
            get {
                return this.tableBlockingCollector;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public ProfilerCollectorDataTable ProfilerCollector {
            get {
                return this.tableProfilerCollector;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public EventsDataTable Events {
            get {
                return this.tableEvents;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public EventTypeDataTable EventType {
            get {
                return this.tableEventType;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public EventDataTable Event {
            get {
                return this.tableEvent;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public CollectorDataTable Collector {
            get {
                return this.tableCollector;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public CustomDiagGroupDataTable CustomDiagGroup {
            get {
                return this.tableCustomDiagGroup;
            }
        }
        
        public override DataSet Clone() {
            NewDataSet cln = ((NewDataSet)(base.Clone()));
            cln.InitVars();
            return cln;
        }
        
        protected override bool ShouldSerializeTables() {
            return false;
        }
        
        protected override bool ShouldSerializeRelations() {
            return false;
        }
        
        protected override void ReadXmlSerializable(XmlReader reader) {
            this.Reset();
            DataSet ds = new DataSet();
            ds.ReadXml(reader);
            if ((ds.Tables["Collection"] != null)) {
                this.Tables.Add(new CollectionDataTable(ds.Tables["Collection"]));
            }
            if ((ds.Tables["Machines"] != null)) {
                this.Tables.Add(new MachinesDataTable(ds.Tables["Machines"]));
            }
            if ((ds.Tables["Machine"] != null)) {
                this.Tables.Add(new MachineDataTable(ds.Tables["Machine"]));
            }
            if ((ds.Tables["MachineCollectors"] != null)) {
                this.Tables.Add(new MachineCollectorsDataTable(ds.Tables["MachineCollectors"]));
            }
            if ((ds.Tables["EventlogCollector"] != null)) {
                this.Tables.Add(new EventlogCollectorDataTable(ds.Tables["EventlogCollector"]));
            }
            if ((ds.Tables["PerfmonCollector"] != null)) {
                this.Tables.Add(new PerfmonCollectorDataTable(ds.Tables["PerfmonCollector"]));
            }
            if ((ds.Tables["PerfmonCounters"] != null)) {
                this.Tables.Add(new PerfmonCountersDataTable(ds.Tables["PerfmonCounters"]));
            }
            if ((ds.Tables["PerfmonObject"] != null)) {
                this.Tables.Add(new PerfmonObjectDataTable(ds.Tables["PerfmonObject"]));
            }
            if ((ds.Tables["PerfmonCounter"] != null)) {
                this.Tables.Add(new PerfmonCounterDataTable(ds.Tables["PerfmonCounter"]));
            }
            if ((ds.Tables["MachineCollector"] != null)) {
                this.Tables.Add(new MachineCollectorDataTable(ds.Tables["MachineCollector"]));
            }
            if ((ds.Tables["Instances"] != null)) {
                this.Tables.Add(new InstancesDataTable(ds.Tables["Instances"]));
            }
            if ((ds.Tables["Instance"] != null)) {
                this.Tables.Add(new InstanceDataTable(ds.Tables["Instance"]));
            }
            if ((ds.Tables["Collectors"] != null)) {
                this.Tables.Add(new CollectorsDataTable(ds.Tables["Collectors"]));
            }
            if ((ds.Tables["SqldiagCollector"] != null)) {
                this.Tables.Add(new SqldiagCollectorDataTable(ds.Tables["SqldiagCollector"]));
            }
            if ((ds.Tables["BlockingCollector"] != null)) {
                this.Tables.Add(new BlockingCollectorDataTable(ds.Tables["BlockingCollector"]));
            }
            if ((ds.Tables["ProfilerCollector"] != null)) {
                this.Tables.Add(new ProfilerCollectorDataTable(ds.Tables["ProfilerCollector"]));
            }
            if ((ds.Tables["Events"] != null)) {
                this.Tables.Add(new EventsDataTable(ds.Tables["Events"]));
            }
            if ((ds.Tables["EventType"] != null)) {
                this.Tables.Add(new EventTypeDataTable(ds.Tables["EventType"]));
            }
            if ((ds.Tables["Event"] != null)) {
                this.Tables.Add(new EventDataTable(ds.Tables["Event"]));
            }
            if ((ds.Tables["Collector"] != null)) {
                this.Tables.Add(new CollectorDataTable(ds.Tables["Collector"]));
            }
            if ((ds.Tables["CustomDiagGroup"] != null)) {
                this.Tables.Add(new CustomDiagGroupDataTable(ds.Tables["CustomDiagGroup"]));
            }
            this.DataSetName = ds.DataSetName;
            this.Prefix = ds.Prefix;
            this.Namespace = ds.Namespace;
            this.Locale = ds.Locale;
            this.CaseSensitive = ds.CaseSensitive;
            this.EnforceConstraints = ds.EnforceConstraints;
            this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
            this.InitVars();
        }
        
        protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
            System.IO.MemoryStream stream = new System.IO.MemoryStream();
            this.WriteXmlSchema(new XmlTextWriter(stream, null));
            stream.Position = 0;
            return System.Xml.Schema.XmlSchema.Read(new XmlTextReader(stream), null);
        }
        
        internal void InitVars() {
            this.tableCollection = ((CollectionDataTable)(this.Tables["Collection"]));
            if ((this.tableCollection != null)) {
                this.tableCollection.InitVars();
            }
            this.tableMachines = ((MachinesDataTable)(this.Tables["Machines"]));
            if ((this.tableMachines != null)) {
                this.tableMachines.InitVars();
            }
            this.tableMachine = ((MachineDataTable)(this.Tables["Machine"]));
            if ((this.tableMachine != null)) {
                this.tableMachine.InitVars();
            }
            this.tableMachineCollectors = ((MachineCollectorsDataTable)(this.Tables["MachineCollectors"]));
            if ((this.tableMachineCollectors != null)) {
                this.tableMachineCollectors.InitVars();
            }
            this.tableEventlogCollector = ((EventlogCollectorDataTable)(this.Tables["EventlogCollector"]));
            if ((this.tableEventlogCollector != null)) {
                this.tableEventlogCollector.InitVars();
            }
            this.tablePerfmonCollector = ((PerfmonCollectorDataTable)(this.Tables["PerfmonCollector"]));
            if ((this.tablePerfmonCollector != null)) {
                this.tablePerfmonCollector.InitVars();
            }
            this.tablePerfmonCounters = ((PerfmonCountersDataTable)(this.Tables["PerfmonCounters"]));
            if ((this.tablePerfmonCounters != null)) {
                this.tablePerfmonCounters.InitVars();
            }
            this.tablePerfmonObject = ((PerfmonObjectDataTable)(this.Tables["PerfmonObject"]));
            if ((this.tablePerfmonObject != null)) {
                this.tablePerfmonObject.InitVars();
            }
            this.tablePerfmonCounter = ((PerfmonCounterDataTable)(this.Tables["PerfmonCounter"]));
            if ((this.tablePerfmonCounter != null)) {
                this.tablePerfmonCounter.InitVars();
            }
            this.tableMachineCollector = ((MachineCollectorDataTable)(this.Tables["MachineCollector"]));
            if ((this.tableMachineCollector != null)) {
                this.tableMachineCollector.InitVars();
            }
            this.tableInstances = ((InstancesDataTable)(this.Tables["Instances"]));
            if ((this.tableInstances != null)) {
                this.tableInstances.InitVars();
            }
            this.tableInstance = ((InstanceDataTable)(this.Tables["Instance"]));
            if ((this.tableInstance != null)) {
                this.tableInstance.InitVars();
            }
            this.tableCollectors = ((CollectorsDataTable)(this.Tables["Collectors"]));
            if ((this.tableCollectors != null)) {
                this.tableCollectors.InitVars();
            }
            this.tableSqldiagCollector = ((SqldiagCollectorDataTable)(this.Tables["SqldiagCollector"]));
            if ((this.tableSqldiagCollector != null)) {
                this.tableSqldiagCollector.InitVars();
            }
            this.tableBlockingCollector = ((BlockingCollectorDataTable)(this.Tables["BlockingCollector"]));
            if ((this.tableBlockingCollector != null)) {
                this.tableBlockingCollector.InitVars();
            }
            this.tableProfilerCollector = ((ProfilerCollectorDataTable)(this.Tables["ProfilerCollector"]));
            if ((this.tableProfilerCollector != null)) {
                this.tableProfilerCollector.InitVars();
            }
            this.tableEvents = ((EventsDataTable)(this.Tables["Events"]));
            if ((this.tableEvents != null)) {
                this.tableEvents.InitVars();
            }
            this.tableEventType = ((EventTypeDataTable)(this.Tables["EventType"]));
            if ((this.tableEventType != null)) {
                this.tableEventType.InitVars();
            }
            this.tableEvent = ((EventDataTable)(this.Tables["Event"]));
            if ((this.tableEvent != null)) {
                this.tableEvent.InitVars();
            }
            this.tableCollector = ((CollectorDataTable)(this.Tables["Collector"]));
            if ((this.tableCollector != null)) {
                this.tableCollector.InitVars();
            }
            this.tableCustomDiagGroup = ((CustomDiagGroupDataTable)(this.Tables["CustomDiagGroup"]));
            if ((this.tableCustomDiagGroup != null)) {
                this.tableCustomDiagGroup.InitVars();
            }
            this.relationPerfmonObject_PerfmonCounter = this.Relations["PerfmonObject_PerfmonCounter"];
            this.relationPerfmonCounters_PerfmonObject = this.Relations["PerfmonCounters_PerfmonObject"];
            this.relationPerfmonCollector_PerfmonCounters = this.Relations["PerfmonCollector_PerfmonCounters"];
            this.relationMachineCollectors_EventlogCollector = this.Relations["MachineCollectors_EventlogCollector"];
            this.relationMachineCollectors_PerfmonCollector = this.Relations["MachineCollectors_PerfmonCollector"];
            this.relationMachineCollectors_MachineCollector = this.Relations["MachineCollectors_MachineCollector"];
            this.relationEventType_Event = this.Relations["EventType_Event"];
            this.relationEvents_EventType = this.Relations["Events_EventType"];
            this.relationProfilerCollector_Events = this.Relations["ProfilerCollector_Events"];
            this.relationCollectors_SqldiagCollector = this.Relations["Collectors_SqldiagCollector"];
            this.relationCollectors_BlockingCollector = this.Relations["Collectors_BlockingCollector"];
            this.relationCollectors_ProfilerCollector = this.Relations["Collectors_ProfilerCollector"];
            this.relationCollectors_Collector = this.Relations["Collectors_Collector"];
            this.relationCollectors_CustomDiagGroup = this.Relations["Collectors_CustomDiagGroup"];
            this.relationInstance_Collectors = this.Relations["Instance_Collectors"];
            this.relationInstances_Instance = this.Relations["Instances_Instance"];
            this.relationMachine_MachineCollectors = this.Relations["Machine_MachineCollectors"];
            this.relationMachine_Instances = this.Relations["Machine_Instances"];
            this.relationMachines_Machine = this.Relations["Machines_Machine"];
            this.relationCollection_Machines = this.Relations["Collection_Machines"];
        }
        
        private void InitClass() {
            this.DataSetName = "NewDataSet";
            this.Prefix = "";
            this.Namespace = "";
            this.Locale = new System.Globalization.CultureInfo("en-US");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.tableCollection = new CollectionDataTable();
            this.Tables.Add(this.tableCollection);
            this.tableMachines = new MachinesDataTable();
            this.Tables.Add(this.tableMachines);
            this.tableMachine = new MachineDataTable();
            this.Tables.Add(this.tableMachine);
            this.tableMachineCollectors = new MachineCollectorsDataTable();
            this.Tables.Add(this.tableMachineCollectors);
            this.tableEventlogCollector = new EventlogCollectorDataTable();
            this.Tables.Add(this.tableEventlogCollector);
            this.tablePerfmonCollector = new PerfmonCollectorDataTable();
            this.Tables.Add(this.tablePerfmonCollector);
            this.tablePerfmonCounters = new PerfmonCountersDataTable();
            this.Tables.Add(this.tablePerfmonCounters);
            this.tablePerfmonObject = new PerfmonObjectDataTable();
            this.Tables.Add(this.tablePerfmonObject);
            this.tablePerfmonCounter = new PerfmonCounterDataTable();
            this.Tables.Add(this.tablePerfmonCounter);
            this.tableMachineCollector = new MachineCollectorDataTable();
            this.Tables.Add(this.tableMachineCollector);
            this.tableInstances = new InstancesDataTable();
            this.Tables.Add(this.tableInstances);
            this.tableInstance = new InstanceDataTable();
            this.Tables.Add(this.tableInstance);
            this.tableCollectors = new CollectorsDataTable();
            this.Tables.Add(this.tableCollectors);
            this.tableSqldiagCollector = new SqldiagCollectorDataTable();
            this.Tables.Add(this.tableSqldiagCollector);
            this.tableBlockingCollector = new BlockingCollectorDataTable();
            this.Tables.Add(this.tableBlockingCollector);
            this.tableProfilerCollector = new ProfilerCollectorDataTable();
            this.Tables.Add(this.tableProfilerCollector);
            this.tableEvents = new EventsDataTable();
            this.Tables.Add(this.tableEvents);
            this.tableEventType = new EventTypeDataTable();
            this.Tables.Add(this.tableEventType);
            this.tableEvent = new EventDataTable();
            this.Tables.Add(this.tableEvent);
            this.tableCollector = new CollectorDataTable();
            this.Tables.Add(this.tableCollector);
            this.tableCustomDiagGroup = new CustomDiagGroupDataTable();
            this.Tables.Add(this.tableCustomDiagGroup);
            ForeignKeyConstraint fkc;
            fkc = new ForeignKeyConstraint("Collection_Machines", new DataColumn[] {
                        this.tableCollection.Collection_IdColumn}, new DataColumn[] {
                        this.tableMachines.Collection_IdColumn});
            this.tableMachines.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Machines_Machine", new DataColumn[] {
                        this.tableMachines.Machines_IdColumn}, new DataColumn[] {
                        this.tableMachine.Machines_IdColumn});
            this.tableMachine.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Machine_MachineCollectors", new DataColumn[] {
                        this.tableMachine.Machine_IdColumn}, new DataColumn[] {
                        this.tableMachineCollectors.Machine_IdColumn});
            this.tableMachineCollectors.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("MachineCollectors_EventlogCollector", new DataColumn[] {
                        this.tableMachineCollectors.MachineCollectors_IdColumn}, new DataColumn[] {
                        this.tableEventlogCollector.MachineCollectors_IdColumn});
            this.tableEventlogCollector.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("MachineCollectors_PerfmonCollector", new DataColumn[] {
                        this.tableMachineCollectors.MachineCollectors_IdColumn}, new DataColumn[] {
                        this.tablePerfmonCollector.MachineCollectors_IdColumn});
            this.tablePerfmonCollector.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("PerfmonCollector_PerfmonCounters", new DataColumn[] {
                        this.tablePerfmonCollector.PerfmonCollector_IdColumn}, new DataColumn[] {
                        this.tablePerfmonCounters.PerfmonCollector_IdColumn});
            this.tablePerfmonCounters.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("PerfmonCounters_PerfmonObject", new DataColumn[] {
                        this.tablePerfmonCounters.PerfmonCounters_IdColumn}, new DataColumn[] {
                        this.tablePerfmonObject.PerfmonCounters_IdColumn});
            this.tablePerfmonObject.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("PerfmonObject_PerfmonCounter", new DataColumn[] {
                        this.tablePerfmonObject.PerfmonObject_IdColumn}, new DataColumn[] {
                        this.tablePerfmonCounter.PerfmonObject_IdColumn});
            this.tablePerfmonCounter.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("MachineCollectors_MachineCollector", new DataColumn[] {
                        this.tableMachineCollectors.MachineCollectors_IdColumn}, new DataColumn[] {
                        this.tableMachineCollector.MachineCollectors_IdColumn});
            this.tableMachineCollector.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Machine_Instances", new DataColumn[] {
                        this.tableMachine.Machine_IdColumn}, new DataColumn[] {
                        this.tableInstances.Machine_IdColumn});
            this.tableInstances.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Instances_Instance", new DataColumn[] {
                        this.tableInstances.Instances_IdColumn}, new DataColumn[] {
                        this.tableInstance.Instances_IdColumn});
            this.tableInstance.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Instance_Collectors", new DataColumn[] {
                        this.tableInstance.Instance_IdColumn}, new DataColumn[] {
                        this.tableCollectors.Instance_IdColumn});
            this.tableCollectors.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Collectors_SqldiagCollector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableSqldiagCollector.Collectors_IdColumn});
            this.tableSqldiagCollector.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Collectors_BlockingCollector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableBlockingCollector.Collectors_IdColumn});
            this.tableBlockingCollector.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Collectors_ProfilerCollector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableProfilerCollector.Collectors_IdColumn});
            this.tableProfilerCollector.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("ProfilerCollector_Events", new DataColumn[] {
                        this.tableProfilerCollector.ProfilerCollector_IdColumn}, new DataColumn[] {
                        this.tableEvents.ProfilerCollector_IdColumn});
            this.tableEvents.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Events_EventType", new DataColumn[] {
                        this.tableEvents.Events_IdColumn}, new DataColumn[] {
                        this.tableEventType.Events_IdColumn});
            this.tableEventType.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("EventType_Event", new DataColumn[] {
                        this.tableEventType.EventType_IdColumn}, new DataColumn[] {
                        this.tableEvent.EventType_IdColumn});
            this.tableEvent.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Collectors_Collector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableCollector.Collectors_IdColumn});
            this.tableCollector.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            fkc = new ForeignKeyConstraint("Collectors_CustomDiagGroup", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableCustomDiagGroup.Collectors_IdColumn});
            this.tableCustomDiagGroup.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            this.relationPerfmonObject_PerfmonCounter = new DataRelation("PerfmonObject_PerfmonCounter", new DataColumn[] {
                        this.tablePerfmonObject.PerfmonObject_IdColumn}, new DataColumn[] {
                        this.tablePerfmonCounter.PerfmonObject_IdColumn}, false);
            this.relationPerfmonObject_PerfmonCounter.Nested = true;
            this.Relations.Add(this.relationPerfmonObject_PerfmonCounter);
            this.relationPerfmonCounters_PerfmonObject = new DataRelation("PerfmonCounters_PerfmonObject", new DataColumn[] {
                        this.tablePerfmonCounters.PerfmonCounters_IdColumn}, new DataColumn[] {
                        this.tablePerfmonObject.PerfmonCounters_IdColumn}, false);
            this.relationPerfmonCounters_PerfmonObject.Nested = true;
            this.Relations.Add(this.relationPerfmonCounters_PerfmonObject);
            this.relationPerfmonCollector_PerfmonCounters = new DataRelation("PerfmonCollector_PerfmonCounters", new DataColumn[] {
                        this.tablePerfmonCollector.PerfmonCollector_IdColumn}, new DataColumn[] {
                        this.tablePerfmonCounters.PerfmonCollector_IdColumn}, false);
            this.relationPerfmonCollector_PerfmonCounters.Nested = true;
            this.Relations.Add(this.relationPerfmonCollector_PerfmonCounters);
            this.relationMachineCollectors_EventlogCollector = new DataRelation("MachineCollectors_EventlogCollector", new DataColumn[] {
                        this.tableMachineCollectors.MachineCollectors_IdColumn}, new DataColumn[] {
                        this.tableEventlogCollector.MachineCollectors_IdColumn}, false);
            this.relationMachineCollectors_EventlogCollector.Nested = true;
            this.Relations.Add(this.relationMachineCollectors_EventlogCollector);
            this.relationMachineCollectors_PerfmonCollector = new DataRelation("MachineCollectors_PerfmonCollector", new DataColumn[] {
                        this.tableMachineCollectors.MachineCollectors_IdColumn}, new DataColumn[] {
                        this.tablePerfmonCollector.MachineCollectors_IdColumn}, false);
            this.relationMachineCollectors_PerfmonCollector.Nested = true;
            this.Relations.Add(this.relationMachineCollectors_PerfmonCollector);
            this.relationMachineCollectors_MachineCollector = new DataRelation("MachineCollectors_MachineCollector", new DataColumn[] {
                        this.tableMachineCollectors.MachineCollectors_IdColumn}, new DataColumn[] {
                        this.tableMachineCollector.MachineCollectors_IdColumn}, false);
            this.relationMachineCollectors_MachineCollector.Nested = true;
            this.Relations.Add(this.relationMachineCollectors_MachineCollector);
            this.relationEventType_Event = new DataRelation("EventType_Event", new DataColumn[] {
                        this.tableEventType.EventType_IdColumn}, new DataColumn[] {
                        this.tableEvent.EventType_IdColumn}, false);
            this.relationEventType_Event.Nested = true;
            this.Relations.Add(this.relationEventType_Event);
            this.relationEvents_EventType = new DataRelation("Events_EventType", new DataColumn[] {
                        this.tableEvents.Events_IdColumn}, new DataColumn[] {
                        this.tableEventType.Events_IdColumn}, false);
            this.relationEvents_EventType.Nested = true;
            this.Relations.Add(this.relationEvents_EventType);
            this.relationProfilerCollector_Events = new DataRelation("ProfilerCollector_Events", new DataColumn[] {
                        this.tableProfilerCollector.ProfilerCollector_IdColumn}, new DataColumn[] {
                        this.tableEvents.ProfilerCollector_IdColumn}, false);
            this.relationProfilerCollector_Events.Nested = true;
            this.Relations.Add(this.relationProfilerCollector_Events);
            this.relationCollectors_SqldiagCollector = new DataRelation("Collectors_SqldiagCollector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableSqldiagCollector.Collectors_IdColumn}, false);
            this.relationCollectors_SqldiagCollector.Nested = true;
            this.Relations.Add(this.relationCollectors_SqldiagCollector);
            this.relationCollectors_BlockingCollector = new DataRelation("Collectors_BlockingCollector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableBlockingCollector.Collectors_IdColumn}, false);
            this.relationCollectors_BlockingCollector.Nested = true;
            this.Relations.Add(this.relationCollectors_BlockingCollector);
            this.relationCollectors_ProfilerCollector = new DataRelation("Collectors_ProfilerCollector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableProfilerCollector.Collectors_IdColumn}, false);
            this.relationCollectors_ProfilerCollector.Nested = true;
            this.Relations.Add(this.relationCollectors_ProfilerCollector);
            this.relationCollectors_Collector = new DataRelation("Collectors_Collector", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableCollector.Collectors_IdColumn}, false);
            this.relationCollectors_Collector.Nested = true;
            this.Relations.Add(this.relationCollectors_Collector);
            this.relationCollectors_CustomDiagGroup = new DataRelation("Collectors_CustomDiagGroup", new DataColumn[] {
                        this.tableCollectors.Collectors_IdColumn}, new DataColumn[] {
                        this.tableCustomDiagGroup.Collectors_IdColumn}, false);
            this.relationCollectors_CustomDiagGroup.Nested = true;
            this.Relations.Add(this.relationCollectors_CustomDiagGroup);
            this.relationInstance_Collectors = new DataRelation("Instance_Collectors", new DataColumn[] {
                        this.tableInstance.Instance_IdColumn}, new DataColumn[] {
                        this.tableCollectors.Instance_IdColumn}, false);
            this.relationInstance_Collectors.Nested = true;
            this.Relations.Add(this.relationInstance_Collectors);
            this.relationInstances_Instance = new DataRelation("Instances_Instance", new DataColumn[] {
                        this.tableInstances.Instances_IdColumn}, new DataColumn[] {
                        this.tableInstance.Instances_IdColumn}, false);
            this.relationInstances_Instance.Nested = true;
            this.Relations.Add(this.relationInstances_Instance);
            this.relationMachine_MachineCollectors = new DataRelation("Machine_MachineCollectors", new DataColumn[] {
                        this.tableMachine.Machine_IdColumn}, new DataColumn[] {
                        this.tableMachineCollectors.Machine_IdColumn}, false);
            this.relationMachine_MachineCollectors.Nested = true;
            this.Relations.Add(this.relationMachine_MachineCollectors);
            this.relationMachine_Instances = new DataRelation("Machine_Instances", new DataColumn[] {
                        this.tableMachine.Machine_IdColumn}, new DataColumn[] {
                        this.tableInstances.Machine_IdColumn}, false);
            this.relationMachine_Instances.Nested = true;
            this.Relations.Add(this.relationMachine_Instances);
            this.relationMachines_Machine = new DataRelation("Machines_Machine", new DataColumn[] {
                        this.tableMachines.Machines_IdColumn}, new DataColumn[] {
                        this.tableMachine.Machines_IdColumn}, false);
            this.relationMachines_Machine.Nested = true;
            this.Relations.Add(this.relationMachines_Machine);
            this.relationCollection_Machines = new DataRelation("Collection_Machines", new DataColumn[] {
                        this.tableCollection.Collection_IdColumn}, new DataColumn[] {
                        this.tableMachines.Collection_IdColumn}, false);
            this.relationCollection_Machines.Nested = true;
            this.Relations.Add(this.relationCollection_Machines);
        }
        
        private bool ShouldSerializeCollection() {
            return false;
        }
        
        private bool ShouldSerializeMachines() {
            return false;
        }
        
        private bool ShouldSerializeMachine() {
            return false;
        }
        
        private bool ShouldSerializeMachineCollectors() {
            return false;
        }
        
        private bool ShouldSerializeEventlogCollector() {
            return false;
        }
        
        private bool ShouldSerializePerfmonCollector() {
            return false;
        }
        
        private bool ShouldSerializePerfmonCounters() {
            return false;
        }
        
        private bool ShouldSerializePerfmonObject() {
            return false;
        }
        
        private bool ShouldSerializePerfmonCounter() {
            return false;
        }
        
        private bool ShouldSerializeMachineCollector() {
            return false;
        }
        
        private bool ShouldSerializeInstances() {
            return false;
        }
        
        private bool ShouldSerializeInstance() {
            return false;
        }
        
        private bool ShouldSerializeCollectors() {
            return false;
        }
        
        private bool ShouldSerializeSqldiagCollector() {
            return false;
        }
        
        private bool ShouldSerializeBlockingCollector() {
            return false;
        }
        
        private bool ShouldSerializeProfilerCollector() {
            return false;
        }
        
        private bool ShouldSerializeEvents() {
            return false;
        }
        
        private bool ShouldSerializeEventType() {
            return false;
        }
        
        private bool ShouldSerializeEvent() {
            return false;
        }
        
        private bool ShouldSerializeCollector() {
            return false;
        }
        
        private bool ShouldSerializeCustomDiagGroup() {
            return false;
        }
        
        private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
            if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
                this.InitVars();
            }
        }
        
        public delegate void CollectionRowChangeEventHandler(object sender, CollectionRowChangeEvent e);
        
        public delegate void MachinesRowChangeEventHandler(object sender, MachinesRowChangeEvent e);
        
        public delegate void MachineRowChangeEventHandler(object sender, MachineRowChangeEvent e);
        
        public delegate void MachineCollectorsRowChangeEventHandler(object sender, MachineCollectorsRowChangeEvent e);
        
        public delegate void EventlogCollectorRowChangeEventHandler(object sender, EventlogCollectorRowChangeEvent e);
        
        public delegate void PerfmonCollectorRowChangeEventHandler(object sender, PerfmonCollectorRowChangeEvent e);
        
        public delegate void PerfmonCountersRowChangeEventHandler(object sender, PerfmonCountersRowChangeEvent e);
        
        public delegate void PerfmonObjectRowChangeEventHandler(object sender, PerfmonObjectRowChangeEvent e);
        
        public delegate void PerfmonCounterRowChangeEventHandler(object sender, PerfmonCounterRowChangeEvent e);
        
        public delegate void MachineCollectorRowChangeEventHandler(object sender, MachineCollectorRowChangeEvent e);
        
        public delegate void InstancesRowChangeEventHandler(object sender, InstancesRowChangeEvent e);
        
        public delegate void InstanceRowChangeEventHandler(object sender, InstanceRowChangeEvent e);
        
        public delegate void CollectorsRowChangeEventHandler(object sender, CollectorsRowChangeEvent e);
        
        public delegate void SqldiagCollectorRowChangeEventHandler(object sender, SqldiagCollectorRowChangeEvent e);
        
        public delegate void BlockingCollectorRowChangeEventHandler(object sender, BlockingCollectorRowChangeEvent e);
        
        public delegate void ProfilerCollectorRowChangeEventHandler(object sender, ProfilerCollectorRowChangeEvent e);
        
        public delegate void EventsRowChangeEventHandler(object sender, EventsRowChangeEvent e);
        
        public delegate void EventTypeRowChangeEventHandler(object sender, EventTypeRowChangeEvent e);
        
        public delegate void EventRowChangeEventHandler(object sender, EventRowChangeEvent e);
        
        public delegate void CollectorRowChangeEventHandler(object sender, CollectorRowChangeEvent e);
        
        public delegate void CustomDiagGroupRowChangeEventHandler(object sender, CustomDiagGroupRowChangeEvent e);
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectionDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnsetupver;
            
            private DataColumn columncasenumber;
            
            private DataColumn columnCollection_Id;
            
            internal CollectionDataTable() : 
                    base("Collection") {
                this.InitClass();
            }
            
            internal CollectionDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn setupverColumn {
                get {
                    return this.columnsetupver;
                }
            }
            
            internal DataColumn casenumberColumn {
                get {
                    return this.columncasenumber;
                }
            }
            
            internal DataColumn Collection_IdColumn {
                get {
                    return this.columnCollection_Id;
                }
            }
            
            public CollectionRow this[int index] {
                get {
                    return ((CollectionRow)(this.Rows[index]));
                }
            }
            
            public event CollectionRowChangeEventHandler CollectionRowChanged;
            
            public event CollectionRowChangeEventHandler CollectionRowChanging;
            
            public event CollectionRowChangeEventHandler CollectionRowDeleted;
            
            public event CollectionRowChangeEventHandler CollectionRowDeleting;
            
            public void AddCollectionRow(CollectionRow row) {
                this.Rows.Add(row);
            }
            
            public CollectionRow AddCollectionRow(string setupver, string casenumber) {
                CollectionRow rowCollectionRow = ((CollectionRow)(this.NewRow()));
                rowCollectionRow.ItemArray = new object[] {
                        setupver,
                        casenumber,
                        null};
                this.Rows.Add(rowCollectionRow);
                return rowCollectionRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                CollectionDataTable cln = ((CollectionDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new CollectionDataTable();
            }
            
            internal void InitVars() {
                this.columnsetupver = this.Columns["setupver"];
                this.columncasenumber = this.Columns["casenumber"];
                this.columnCollection_Id = this.Columns["Collection_Id"];
            }
            
            private void InitClass() {
                this.columnsetupver = new DataColumn("setupver", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnsetupver);
                this.columncasenumber = new DataColumn("casenumber", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columncasenumber);
                this.columnCollection_Id = new DataColumn("Collection_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollection_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnCollection_Id}, true));
                this.columnsetupver.Namespace = "";
                this.columncasenumber.Namespace = "";
                this.columnCollection_Id.AutoIncrement = true;
                this.columnCollection_Id.AllowDBNull = false;
                this.columnCollection_Id.Unique = true;
            }
            
            public CollectionRow NewCollectionRow() {
                return ((CollectionRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new CollectionRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(CollectionRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.CollectionRowChanged != null)) {
                    this.CollectionRowChanged(this, new CollectionRowChangeEvent(((CollectionRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.CollectionRowChanging != null)) {
                    this.CollectionRowChanging(this, new CollectionRowChangeEvent(((CollectionRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.CollectionRowDeleted != null)) {
                    this.CollectionRowDeleted(this, new CollectionRowChangeEvent(((CollectionRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.CollectionRowDeleting != null)) {
                    this.CollectionRowDeleting(this, new CollectionRowChangeEvent(((CollectionRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveCollectionRow(CollectionRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectionRow : DataRow {
            
            private CollectionDataTable tableCollection;
            
            internal CollectionRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableCollection = ((CollectionDataTable)(this.Table));
            }
            
            public string setupver {
                get {
                    try {
                        return ((string)(this[this.tableCollection.setupverColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollection.setupverColumn] = value;
                }
            }
            
            public string casenumber {
                get {
                    try {
                        return ((string)(this[this.tableCollection.casenumberColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollection.casenumberColumn] = value;
                }
            }
            
            public bool IssetupverNull() {
                return this.IsNull(this.tableCollection.setupverColumn);
            }
            
            public void SetsetupverNull() {
                this[this.tableCollection.setupverColumn] = System.Convert.DBNull;
            }
            
            public bool IscasenumberNull() {
                return this.IsNull(this.tableCollection.casenumberColumn);
            }
            
            public void SetcasenumberNull() {
                this[this.tableCollection.casenumberColumn] = System.Convert.DBNull;
            }
            
            public MachinesRow[] GetMachinesRows() {
                return ((MachinesRow[])(this.GetChildRows(this.Table.ChildRelations["Collection_Machines"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectionRowChangeEvent : EventArgs {
            
            private CollectionRow eventRow;
            
            private DataRowAction eventAction;
            
            public CollectionRowChangeEvent(CollectionRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public CollectionRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachinesDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnMachines_Id;
            
            private DataColumn columnCollection_Id;
            
            internal MachinesDataTable() : 
                    base("Machines") {
                this.InitClass();
            }
            
            internal MachinesDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn Machines_IdColumn {
                get {
                    return this.columnMachines_Id;
                }
            }
            
            internal DataColumn Collection_IdColumn {
                get {
                    return this.columnCollection_Id;
                }
            }
            
            public MachinesRow this[int index] {
                get {
                    return ((MachinesRow)(this.Rows[index]));
                }
            }
            
            public event MachinesRowChangeEventHandler MachinesRowChanged;
            
            public event MachinesRowChangeEventHandler MachinesRowChanging;
            
            public event MachinesRowChangeEventHandler MachinesRowDeleted;
            
            public event MachinesRowChangeEventHandler MachinesRowDeleting;
            
            public void AddMachinesRow(MachinesRow row) {
                this.Rows.Add(row);
            }
            
            public MachinesRow AddMachinesRow(CollectionRow parentCollectionRowByCollection_Machines) {
                MachinesRow rowMachinesRow = ((MachinesRow)(this.NewRow()));
                rowMachinesRow.ItemArray = new object[] {
                        null,
                        parentCollectionRowByCollection_Machines[2]};
                this.Rows.Add(rowMachinesRow);
                return rowMachinesRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                MachinesDataTable cln = ((MachinesDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new MachinesDataTable();
            }
            
            internal void InitVars() {
                this.columnMachines_Id = this.Columns["Machines_Id"];
                this.columnCollection_Id = this.Columns["Collection_Id"];
            }
            
            private void InitClass() {
                this.columnMachines_Id = new DataColumn("Machines_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachines_Id);
                this.columnCollection_Id = new DataColumn("Collection_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollection_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnMachines_Id}, true));
                this.columnMachines_Id.AutoIncrement = true;
                this.columnMachines_Id.AllowDBNull = false;
                this.columnMachines_Id.Unique = true;
            }
            
            public MachinesRow NewMachinesRow() {
                return ((MachinesRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new MachinesRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(MachinesRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.MachinesRowChanged != null)) {
                    this.MachinesRowChanged(this, new MachinesRowChangeEvent(((MachinesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.MachinesRowChanging != null)) {
                    this.MachinesRowChanging(this, new MachinesRowChangeEvent(((MachinesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.MachinesRowDeleted != null)) {
                    this.MachinesRowDeleted(this, new MachinesRowChangeEvent(((MachinesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.MachinesRowDeleting != null)) {
                    this.MachinesRowDeleting(this, new MachinesRowChangeEvent(((MachinesRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveMachinesRow(MachinesRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachinesRow : DataRow {
            
            private MachinesDataTable tableMachines;
            
            internal MachinesRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableMachines = ((MachinesDataTable)(this.Table));
            }
            
            public CollectionRow CollectionRow {
                get {
                    return ((CollectionRow)(this.GetParentRow(this.Table.ParentRelations["Collection_Machines"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Collection_Machines"]);
                }
            }
            
            public MachineRow[] GetMachineRows() {
                return ((MachineRow[])(this.GetChildRows(this.Table.ChildRelations["Machines_Machine"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachinesRowChangeEvent : EventArgs {
            
            private MachinesRow eventRow;
            
            private DataRowAction eventAction;
            
            public MachinesRowChangeEvent(MachinesRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public MachinesRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnname;
            
            private DataColumn columnMachine_Id;
            
            private DataColumn columnMachines_Id;
            
            internal MachineDataTable() : 
                    base("Machine") {
                this.InitClass();
            }
            
            internal MachineDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn Machine_IdColumn {
                get {
                    return this.columnMachine_Id;
                }
            }
            
            internal DataColumn Machines_IdColumn {
                get {
                    return this.columnMachines_Id;
                }
            }
            
            public MachineRow this[int index] {
                get {
                    return ((MachineRow)(this.Rows[index]));
                }
            }
            
            public event MachineRowChangeEventHandler MachineRowChanged;
            
            public event MachineRowChangeEventHandler MachineRowChanging;
            
            public event MachineRowChangeEventHandler MachineRowDeleted;
            
            public event MachineRowChangeEventHandler MachineRowDeleting;
            
            public void AddMachineRow(MachineRow row) {
                this.Rows.Add(row);
            }
            
            public MachineRow AddMachineRow(string name, MachinesRow parentMachinesRowByMachines_Machine) {
                MachineRow rowMachineRow = ((MachineRow)(this.NewRow()));
                rowMachineRow.ItemArray = new object[] {
                        name,
                        null,
                        parentMachinesRowByMachines_Machine[0]};
                this.Rows.Add(rowMachineRow);
                return rowMachineRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                MachineDataTable cln = ((MachineDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new MachineDataTable();
            }
            
            internal void InitVars() {
                this.columnname = this.Columns["name"];
                this.columnMachine_Id = this.Columns["Machine_Id"];
                this.columnMachines_Id = this.Columns["Machines_Id"];
            }
            
            private void InitClass() {
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columnMachine_Id = new DataColumn("Machine_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachine_Id);
                this.columnMachines_Id = new DataColumn("Machines_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachines_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnMachine_Id}, true));
                this.columnname.Namespace = "";
                this.columnname.DefaultValue = "";
                this.columnMachine_Id.AutoIncrement = true;
                this.columnMachine_Id.AllowDBNull = false;
                this.columnMachine_Id.Unique = true;
            }
            
            public MachineRow NewMachineRow() {
                return ((MachineRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new MachineRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(MachineRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.MachineRowChanged != null)) {
                    this.MachineRowChanged(this, new MachineRowChangeEvent(((MachineRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.MachineRowChanging != null)) {
                    this.MachineRowChanging(this, new MachineRowChangeEvent(((MachineRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.MachineRowDeleted != null)) {
                    this.MachineRowDeleted(this, new MachineRowChangeEvent(((MachineRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.MachineRowDeleting != null)) {
                    this.MachineRowDeleting(this, new MachineRowChangeEvent(((MachineRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveMachineRow(MachineRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineRow : DataRow {
            
            private MachineDataTable tableMachine;
            
            internal MachineRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableMachine = ((MachineDataTable)(this.Table));
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tableMachine.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableMachine.nameColumn] = value;
                }
            }
            
            public MachinesRow MachinesRow {
                get {
                    return ((MachinesRow)(this.GetParentRow(this.Table.ParentRelations["Machines_Machine"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Machines_Machine"]);
                }
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tableMachine.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tableMachine.nameColumn] = System.Convert.DBNull;
            }
            
            public MachineCollectorsRow[] GetMachineCollectorsRows() {
                return ((MachineCollectorsRow[])(this.GetChildRows(this.Table.ChildRelations["Machine_MachineCollectors"])));
            }
            
            public InstancesRow[] GetInstancesRows() {
                return ((InstancesRow[])(this.GetChildRows(this.Table.ChildRelations["Machine_Instances"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineRowChangeEvent : EventArgs {
            
            private MachineRow eventRow;
            
            private DataRowAction eventAction;
            
            public MachineRowChangeEvent(MachineRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public MachineRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineCollectorsDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnMachineCollectors_Id;
            
            private DataColumn columnMachine_Id;
            
            internal MachineCollectorsDataTable() : 
                    base("MachineCollectors") {
                this.InitClass();
            }
            
            internal MachineCollectorsDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn MachineCollectors_IdColumn {
                get {
                    return this.columnMachineCollectors_Id;
                }
            }
            
            internal DataColumn Machine_IdColumn {
                get {
                    return this.columnMachine_Id;
                }
            }
            
            public MachineCollectorsRow this[int index] {
                get {
                    return ((MachineCollectorsRow)(this.Rows[index]));
                }
            }
            
            public event MachineCollectorsRowChangeEventHandler MachineCollectorsRowChanged;
            
            public event MachineCollectorsRowChangeEventHandler MachineCollectorsRowChanging;
            
            public event MachineCollectorsRowChangeEventHandler MachineCollectorsRowDeleted;
            
            public event MachineCollectorsRowChangeEventHandler MachineCollectorsRowDeleting;
            
            public void AddMachineCollectorsRow(MachineCollectorsRow row) {
                this.Rows.Add(row);
            }
            
            public MachineCollectorsRow AddMachineCollectorsRow(MachineRow parentMachineRowByMachine_MachineCollectors) {
                MachineCollectorsRow rowMachineCollectorsRow = ((MachineCollectorsRow)(this.NewRow()));
                rowMachineCollectorsRow.ItemArray = new object[] {
                        null,
                        parentMachineRowByMachine_MachineCollectors[1]};
                this.Rows.Add(rowMachineCollectorsRow);
                return rowMachineCollectorsRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                MachineCollectorsDataTable cln = ((MachineCollectorsDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new MachineCollectorsDataTable();
            }
            
            internal void InitVars() {
                this.columnMachineCollectors_Id = this.Columns["MachineCollectors_Id"];
                this.columnMachine_Id = this.Columns["Machine_Id"];
            }
            
            private void InitClass() {
                this.columnMachineCollectors_Id = new DataColumn("MachineCollectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachineCollectors_Id);
                this.columnMachine_Id = new DataColumn("Machine_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachine_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnMachineCollectors_Id}, true));
                this.columnMachineCollectors_Id.AutoIncrement = true;
                this.columnMachineCollectors_Id.AllowDBNull = false;
                this.columnMachineCollectors_Id.Unique = true;
            }
            
            public MachineCollectorsRow NewMachineCollectorsRow() {
                return ((MachineCollectorsRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new MachineCollectorsRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(MachineCollectorsRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.MachineCollectorsRowChanged != null)) {
                    this.MachineCollectorsRowChanged(this, new MachineCollectorsRowChangeEvent(((MachineCollectorsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.MachineCollectorsRowChanging != null)) {
                    this.MachineCollectorsRowChanging(this, new MachineCollectorsRowChangeEvent(((MachineCollectorsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.MachineCollectorsRowDeleted != null)) {
                    this.MachineCollectorsRowDeleted(this, new MachineCollectorsRowChangeEvent(((MachineCollectorsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.MachineCollectorsRowDeleting != null)) {
                    this.MachineCollectorsRowDeleting(this, new MachineCollectorsRowChangeEvent(((MachineCollectorsRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveMachineCollectorsRow(MachineCollectorsRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineCollectorsRow : DataRow {
            
            private MachineCollectorsDataTable tableMachineCollectors;
            
            internal MachineCollectorsRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableMachineCollectors = ((MachineCollectorsDataTable)(this.Table));
            }
            
            public MachineRow MachineRow {
                get {
                    return ((MachineRow)(this.GetParentRow(this.Table.ParentRelations["Machine_MachineCollectors"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Machine_MachineCollectors"]);
                }
            }
            
            public EventlogCollectorRow[] GetEventlogCollectorRows() {
                return ((EventlogCollectorRow[])(this.GetChildRows(this.Table.ChildRelations["MachineCollectors_EventlogCollector"])));
            }
            
            public PerfmonCollectorRow[] GetPerfmonCollectorRows() {
                return ((PerfmonCollectorRow[])(this.GetChildRows(this.Table.ChildRelations["MachineCollectors_PerfmonCollector"])));
            }
            
            public MachineCollectorRow[] GetMachineCollectorRows() {
                return ((MachineCollectorRow[])(this.GetChildRows(this.Table.ChildRelations["MachineCollectors_MachineCollector"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineCollectorsRowChangeEvent : EventArgs {
            
            private MachineCollectorsRow eventRow;
            
            private DataRowAction eventAction;
            
            public MachineCollectorsRowChangeEvent(MachineCollectorsRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public MachineCollectorsRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventlogCollectorDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnstartup;
            
            private DataColumn columnshutdown;
            
            private DataColumn columnMachineCollectors_Id;
            
            internal EventlogCollectorDataTable() : 
                    base("EventlogCollector") {
                this.InitClass();
            }
            
            internal EventlogCollectorDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn startupColumn {
                get {
                    return this.columnstartup;
                }
            }
            
            internal DataColumn shutdownColumn {
                get {
                    return this.columnshutdown;
                }
            }
            
            internal DataColumn MachineCollectors_IdColumn {
                get {
                    return this.columnMachineCollectors_Id;
                }
            }
            
            public EventlogCollectorRow this[int index] {
                get {
                    return ((EventlogCollectorRow)(this.Rows[index]));
                }
            }
            
            public event EventlogCollectorRowChangeEventHandler EventlogCollectorRowChanged;
            
            public event EventlogCollectorRowChangeEventHandler EventlogCollectorRowChanging;
            
            public event EventlogCollectorRowChangeEventHandler EventlogCollectorRowDeleted;
            
            public event EventlogCollectorRowChangeEventHandler EventlogCollectorRowDeleting;
            
            public void AddEventlogCollectorRow(EventlogCollectorRow row) {
                this.Rows.Add(row);
            }
            
            public EventlogCollectorRow AddEventlogCollectorRow(bool enabled, bool startup, bool shutdown, MachineCollectorsRow parentMachineCollectorsRowByMachineCollectors_EventlogCollector) {
                EventlogCollectorRow rowEventlogCollectorRow = ((EventlogCollectorRow)(this.NewRow()));
                rowEventlogCollectorRow.ItemArray = new object[] {
                        enabled,
                        startup,
                        shutdown,
                        parentMachineCollectorsRowByMachineCollectors_EventlogCollector[0]};
                this.Rows.Add(rowEventlogCollectorRow);
                return rowEventlogCollectorRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                EventlogCollectorDataTable cln = ((EventlogCollectorDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new EventlogCollectorDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnstartup = this.Columns["startup"];
                this.columnshutdown = this.Columns["shutdown"];
                this.columnMachineCollectors_Id = this.Columns["MachineCollectors_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnstartup = new DataColumn("startup", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnstartup);
                this.columnshutdown = new DataColumn("shutdown", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnshutdown);
                this.columnMachineCollectors_Id = new DataColumn("MachineCollectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachineCollectors_Id);
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnstartup.Namespace = "";
                this.columnstartup.DefaultValue = false;
                this.columnshutdown.Namespace = "";
                this.columnshutdown.DefaultValue = false;
            }
            
            public EventlogCollectorRow NewEventlogCollectorRow() {
                return ((EventlogCollectorRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new EventlogCollectorRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(EventlogCollectorRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.EventlogCollectorRowChanged != null)) {
                    this.EventlogCollectorRowChanged(this, new EventlogCollectorRowChangeEvent(((EventlogCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.EventlogCollectorRowChanging != null)) {
                    this.EventlogCollectorRowChanging(this, new EventlogCollectorRowChangeEvent(((EventlogCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.EventlogCollectorRowDeleted != null)) {
                    this.EventlogCollectorRowDeleted(this, new EventlogCollectorRowChangeEvent(((EventlogCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.EventlogCollectorRowDeleting != null)) {
                    this.EventlogCollectorRowDeleting(this, new EventlogCollectorRowChangeEvent(((EventlogCollectorRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveEventlogCollectorRow(EventlogCollectorRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventlogCollectorRow : DataRow {
            
            private EventlogCollectorDataTable tableEventlogCollector;
            
            internal EventlogCollectorRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableEventlogCollector = ((EventlogCollectorDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableEventlogCollector.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEventlogCollector.enabledColumn] = value;
                }
            }
            
            public bool startup {
                get {
                    try {
                        return ((bool)(this[this.tableEventlogCollector.startupColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEventlogCollector.startupColumn] = value;
                }
            }
            
            public bool shutdown {
                get {
                    try {
                        return ((bool)(this[this.tableEventlogCollector.shutdownColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEventlogCollector.shutdownColumn] = value;
                }
            }
            
            public MachineCollectorsRow MachineCollectorsRow {
                get {
                    return ((MachineCollectorsRow)(this.GetParentRow(this.Table.ParentRelations["MachineCollectors_EventlogCollector"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["MachineCollectors_EventlogCollector"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableEventlogCollector.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableEventlogCollector.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsstartupNull() {
                return this.IsNull(this.tableEventlogCollector.startupColumn);
            }
            
            public void SetstartupNull() {
                this[this.tableEventlogCollector.startupColumn] = System.Convert.DBNull;
            }
            
            public bool IsshutdownNull() {
                return this.IsNull(this.tableEventlogCollector.shutdownColumn);
            }
            
            public void SetshutdownNull() {
                this[this.tableEventlogCollector.shutdownColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventlogCollectorRowChangeEvent : EventArgs {
            
            private EventlogCollectorRow eventRow;
            
            private DataRowAction eventAction;
            
            public EventlogCollectorRowChangeEvent(EventlogCollectorRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public EventlogCollectorRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCollectorDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnpollinginterval;
            
            private DataColumn columnmaxfilesize;
            
            private DataColumn columnPerfmonCollector_Id;
            
            private DataColumn columnMachineCollectors_Id;
            
            internal PerfmonCollectorDataTable() : 
                    base("PerfmonCollector") {
                this.InitClass();
            }
            
            internal PerfmonCollectorDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn pollingintervalColumn {
                get {
                    return this.columnpollinginterval;
                }
            }
            
            internal DataColumn maxfilesizeColumn {
                get {
                    return this.columnmaxfilesize;
                }
            }
            
            internal DataColumn PerfmonCollector_IdColumn {
                get {
                    return this.columnPerfmonCollector_Id;
                }
            }
            
            internal DataColumn MachineCollectors_IdColumn {
                get {
                    return this.columnMachineCollectors_Id;
                }
            }
            
            public PerfmonCollectorRow this[int index] {
                get {
                    return ((PerfmonCollectorRow)(this.Rows[index]));
                }
            }
            
            public event PerfmonCollectorRowChangeEventHandler PerfmonCollectorRowChanged;
            
            public event PerfmonCollectorRowChangeEventHandler PerfmonCollectorRowChanging;
            
            public event PerfmonCollectorRowChangeEventHandler PerfmonCollectorRowDeleted;
            
            public event PerfmonCollectorRowChangeEventHandler PerfmonCollectorRowDeleting;
            
            public void AddPerfmonCollectorRow(PerfmonCollectorRow row) {
                this.Rows.Add(row);
            }
            
            public PerfmonCollectorRow AddPerfmonCollectorRow(bool enabled, int pollinginterval, int maxfilesize, MachineCollectorsRow parentMachineCollectorsRowByMachineCollectors_PerfmonCollector) {
                PerfmonCollectorRow rowPerfmonCollectorRow = ((PerfmonCollectorRow)(this.NewRow()));
                rowPerfmonCollectorRow.ItemArray = new object[] {
                        enabled,
                        pollinginterval,
                        maxfilesize,
                        null,
                        parentMachineCollectorsRowByMachineCollectors_PerfmonCollector[0]};
                this.Rows.Add(rowPerfmonCollectorRow);
                return rowPerfmonCollectorRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                PerfmonCollectorDataTable cln = ((PerfmonCollectorDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new PerfmonCollectorDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnpollinginterval = this.Columns["pollinginterval"];
                this.columnmaxfilesize = this.Columns["maxfilesize"];
                this.columnPerfmonCollector_Id = this.Columns["PerfmonCollector_Id"];
                this.columnMachineCollectors_Id = this.Columns["MachineCollectors_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnpollinginterval = new DataColumn("pollinginterval", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnpollinginterval);
                this.columnmaxfilesize = new DataColumn("maxfilesize", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnmaxfilesize);
                this.columnPerfmonCollector_Id = new DataColumn("PerfmonCollector_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnPerfmonCollector_Id);
                this.columnMachineCollectors_Id = new DataColumn("MachineCollectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachineCollectors_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnPerfmonCollector_Id}, true));
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnpollinginterval.Namespace = "";
                this.columnpollinginterval.DefaultValue = 5;
                this.columnmaxfilesize.Namespace = "";
                this.columnmaxfilesize.DefaultValue = 256;
                this.columnPerfmonCollector_Id.AutoIncrement = true;
                this.columnPerfmonCollector_Id.AllowDBNull = false;
                this.columnPerfmonCollector_Id.Unique = true;
            }
            
            public PerfmonCollectorRow NewPerfmonCollectorRow() {
                return ((PerfmonCollectorRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new PerfmonCollectorRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(PerfmonCollectorRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.PerfmonCollectorRowChanged != null)) {
                    this.PerfmonCollectorRowChanged(this, new PerfmonCollectorRowChangeEvent(((PerfmonCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.PerfmonCollectorRowChanging != null)) {
                    this.PerfmonCollectorRowChanging(this, new PerfmonCollectorRowChangeEvent(((PerfmonCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.PerfmonCollectorRowDeleted != null)) {
                    this.PerfmonCollectorRowDeleted(this, new PerfmonCollectorRowChangeEvent(((PerfmonCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.PerfmonCollectorRowDeleting != null)) {
                    this.PerfmonCollectorRowDeleting(this, new PerfmonCollectorRowChangeEvent(((PerfmonCollectorRow)(e.Row)), e.Action));
                }
            }
            
            public void RemovePerfmonCollectorRow(PerfmonCollectorRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCollectorRow : DataRow {
            
            private PerfmonCollectorDataTable tablePerfmonCollector;
            
            internal PerfmonCollectorRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tablePerfmonCollector = ((PerfmonCollectorDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tablePerfmonCollector.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tablePerfmonCollector.enabledColumn] = value;
                }
            }
            
            public int pollinginterval {
                get {
                    try {
                        return ((int)(this[this.tablePerfmonCollector.pollingintervalColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tablePerfmonCollector.pollingintervalColumn] = value;
                }
            }
            
            public int maxfilesize {
                get {
                    try {
                        return ((int)(this[this.tablePerfmonCollector.maxfilesizeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tablePerfmonCollector.maxfilesizeColumn] = value;
                }
            }
            
            public MachineCollectorsRow MachineCollectorsRow {
                get {
                    return ((MachineCollectorsRow)(this.GetParentRow(this.Table.ParentRelations["MachineCollectors_PerfmonCollector"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["MachineCollectors_PerfmonCollector"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tablePerfmonCollector.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tablePerfmonCollector.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IspollingintervalNull() {
                return this.IsNull(this.tablePerfmonCollector.pollingintervalColumn);
            }
            
            public void SetpollingintervalNull() {
                this[this.tablePerfmonCollector.pollingintervalColumn] = System.Convert.DBNull;
            }
            
            public bool IsmaxfilesizeNull() {
                return this.IsNull(this.tablePerfmonCollector.maxfilesizeColumn);
            }
            
            public void SetmaxfilesizeNull() {
                this[this.tablePerfmonCollector.maxfilesizeColumn] = System.Convert.DBNull;
            }
            
            public PerfmonCountersRow[] GetPerfmonCountersRows() {
                return ((PerfmonCountersRow[])(this.GetChildRows(this.Table.ChildRelations["PerfmonCollector_PerfmonCounters"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCollectorRowChangeEvent : EventArgs {
            
            private PerfmonCollectorRow eventRow;
            
            private DataRowAction eventAction;
            
            public PerfmonCollectorRowChangeEvent(PerfmonCollectorRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public PerfmonCollectorRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCountersDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnPerfmonCounters_Id;
            
            private DataColumn columnPerfmonCollector_Id;
            
            internal PerfmonCountersDataTable() : 
                    base("PerfmonCounters") {
                this.InitClass();
            }
            
            internal PerfmonCountersDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn PerfmonCounters_IdColumn {
                get {
                    return this.columnPerfmonCounters_Id;
                }
            }
            
            internal DataColumn PerfmonCollector_IdColumn {
                get {
                    return this.columnPerfmonCollector_Id;
                }
            }
            
            public PerfmonCountersRow this[int index] {
                get {
                    return ((PerfmonCountersRow)(this.Rows[index]));
                }
            }
            
            public event PerfmonCountersRowChangeEventHandler PerfmonCountersRowChanged;
            
            public event PerfmonCountersRowChangeEventHandler PerfmonCountersRowChanging;
            
            public event PerfmonCountersRowChangeEventHandler PerfmonCountersRowDeleted;
            
            public event PerfmonCountersRowChangeEventHandler PerfmonCountersRowDeleting;
            
            public void AddPerfmonCountersRow(PerfmonCountersRow row) {
                this.Rows.Add(row);
            }
            
            public PerfmonCountersRow AddPerfmonCountersRow(PerfmonCollectorRow parentPerfmonCollectorRowByPerfmonCollector_PerfmonCounters) {
                PerfmonCountersRow rowPerfmonCountersRow = ((PerfmonCountersRow)(this.NewRow()));
                rowPerfmonCountersRow.ItemArray = new object[] {
                        null,
                        parentPerfmonCollectorRowByPerfmonCollector_PerfmonCounters[3]};
                this.Rows.Add(rowPerfmonCountersRow);
                return rowPerfmonCountersRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                PerfmonCountersDataTable cln = ((PerfmonCountersDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new PerfmonCountersDataTable();
            }
            
            internal void InitVars() {
                this.columnPerfmonCounters_Id = this.Columns["PerfmonCounters_Id"];
                this.columnPerfmonCollector_Id = this.Columns["PerfmonCollector_Id"];
            }
            
            private void InitClass() {
                this.columnPerfmonCounters_Id = new DataColumn("PerfmonCounters_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnPerfmonCounters_Id);
                this.columnPerfmonCollector_Id = new DataColumn("PerfmonCollector_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnPerfmonCollector_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnPerfmonCounters_Id}, true));
                this.columnPerfmonCounters_Id.AutoIncrement = true;
                this.columnPerfmonCounters_Id.AllowDBNull = false;
                this.columnPerfmonCounters_Id.Unique = true;
            }
            
            public PerfmonCountersRow NewPerfmonCountersRow() {
                return ((PerfmonCountersRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new PerfmonCountersRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(PerfmonCountersRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.PerfmonCountersRowChanged != null)) {
                    this.PerfmonCountersRowChanged(this, new PerfmonCountersRowChangeEvent(((PerfmonCountersRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.PerfmonCountersRowChanging != null)) {
                    this.PerfmonCountersRowChanging(this, new PerfmonCountersRowChangeEvent(((PerfmonCountersRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.PerfmonCountersRowDeleted != null)) {
                    this.PerfmonCountersRowDeleted(this, new PerfmonCountersRowChangeEvent(((PerfmonCountersRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.PerfmonCountersRowDeleting != null)) {
                    this.PerfmonCountersRowDeleting(this, new PerfmonCountersRowChangeEvent(((PerfmonCountersRow)(e.Row)), e.Action));
                }
            }
            
            public void RemovePerfmonCountersRow(PerfmonCountersRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCountersRow : DataRow {
            
            private PerfmonCountersDataTable tablePerfmonCounters;
            
            internal PerfmonCountersRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tablePerfmonCounters = ((PerfmonCountersDataTable)(this.Table));
            }
            
            public PerfmonCollectorRow PerfmonCollectorRow {
                get {
                    return ((PerfmonCollectorRow)(this.GetParentRow(this.Table.ParentRelations["PerfmonCollector_PerfmonCounters"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["PerfmonCollector_PerfmonCounters"]);
                }
            }
            
            public PerfmonObjectRow[] GetPerfmonObjectRows() {
                return ((PerfmonObjectRow[])(this.GetChildRows(this.Table.ChildRelations["PerfmonCounters_PerfmonObject"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCountersRowChangeEvent : EventArgs {
            
            private PerfmonCountersRow eventRow;
            
            private DataRowAction eventAction;
            
            public PerfmonCountersRowChangeEvent(PerfmonCountersRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public PerfmonCountersRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonObjectDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnname;
            
            private DataColumn columnPerfmonObject_Id;
            
            private DataColumn columnPerfmonCounters_Id;
            
            internal PerfmonObjectDataTable() : 
                    base("PerfmonObject") {
                this.InitClass();
            }
            
            internal PerfmonObjectDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn PerfmonObject_IdColumn {
                get {
                    return this.columnPerfmonObject_Id;
                }
            }
            
            internal DataColumn PerfmonCounters_IdColumn {
                get {
                    return this.columnPerfmonCounters_Id;
                }
            }
            
            public PerfmonObjectRow this[int index] {
                get {
                    return ((PerfmonObjectRow)(this.Rows[index]));
                }
            }
            
            public event PerfmonObjectRowChangeEventHandler PerfmonObjectRowChanged;
            
            public event PerfmonObjectRowChangeEventHandler PerfmonObjectRowChanging;
            
            public event PerfmonObjectRowChangeEventHandler PerfmonObjectRowDeleted;
            
            public event PerfmonObjectRowChangeEventHandler PerfmonObjectRowDeleting;
            
            public void AddPerfmonObjectRow(PerfmonObjectRow row) {
                this.Rows.Add(row);
            }
            
            public PerfmonObjectRow AddPerfmonObjectRow(bool enabled, string name, PerfmonCountersRow parentPerfmonCountersRowByPerfmonCounters_PerfmonObject) {
                PerfmonObjectRow rowPerfmonObjectRow = ((PerfmonObjectRow)(this.NewRow()));
                rowPerfmonObjectRow.ItemArray = new object[] {
                        enabled,
                        name,
                        null,
                        parentPerfmonCountersRowByPerfmonCounters_PerfmonObject[0]};
                this.Rows.Add(rowPerfmonObjectRow);
                return rowPerfmonObjectRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                PerfmonObjectDataTable cln = ((PerfmonObjectDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new PerfmonObjectDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnname = this.Columns["name"];
                this.columnPerfmonObject_Id = this.Columns["PerfmonObject_Id"];
                this.columnPerfmonCounters_Id = this.Columns["PerfmonCounters_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columnPerfmonObject_Id = new DataColumn("PerfmonObject_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnPerfmonObject_Id);
                this.columnPerfmonCounters_Id = new DataColumn("PerfmonCounters_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnPerfmonCounters_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnPerfmonObject_Id}, true));
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnname.Namespace = "";
                this.columnname.DefaultValue = "";
                this.columnPerfmonObject_Id.AutoIncrement = true;
                this.columnPerfmonObject_Id.AllowDBNull = false;
                this.columnPerfmonObject_Id.Unique = true;
            }
            
            public PerfmonObjectRow NewPerfmonObjectRow() {
                return ((PerfmonObjectRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new PerfmonObjectRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(PerfmonObjectRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.PerfmonObjectRowChanged != null)) {
                    this.PerfmonObjectRowChanged(this, new PerfmonObjectRowChangeEvent(((PerfmonObjectRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.PerfmonObjectRowChanging != null)) {
                    this.PerfmonObjectRowChanging(this, new PerfmonObjectRowChangeEvent(((PerfmonObjectRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.PerfmonObjectRowDeleted != null)) {
                    this.PerfmonObjectRowDeleted(this, new PerfmonObjectRowChangeEvent(((PerfmonObjectRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.PerfmonObjectRowDeleting != null)) {
                    this.PerfmonObjectRowDeleting(this, new PerfmonObjectRowChangeEvent(((PerfmonObjectRow)(e.Row)), e.Action));
                }
            }
            
            public void RemovePerfmonObjectRow(PerfmonObjectRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonObjectRow : DataRow {
            
            private PerfmonObjectDataTable tablePerfmonObject;
            
            internal PerfmonObjectRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tablePerfmonObject = ((PerfmonObjectDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tablePerfmonObject.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tablePerfmonObject.enabledColumn] = value;
                }
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tablePerfmonObject.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tablePerfmonObject.nameColumn] = value;
                }
            }
            
            public PerfmonCountersRow PerfmonCountersRow {
                get {
                    return ((PerfmonCountersRow)(this.GetParentRow(this.Table.ParentRelations["PerfmonCounters_PerfmonObject"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["PerfmonCounters_PerfmonObject"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tablePerfmonObject.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tablePerfmonObject.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tablePerfmonObject.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tablePerfmonObject.nameColumn] = System.Convert.DBNull;
            }
            
            public PerfmonCounterRow[] GetPerfmonCounterRows() {
                return ((PerfmonCounterRow[])(this.GetChildRows(this.Table.ChildRelations["PerfmonObject_PerfmonCounter"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonObjectRowChangeEvent : EventArgs {
            
            private PerfmonObjectRow eventRow;
            
            private DataRowAction eventAction;
            
            public PerfmonObjectRowChangeEvent(PerfmonObjectRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public PerfmonObjectRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCounterDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnname;
            
            private DataColumn columnPerfmonObject_Id;
            
            internal PerfmonCounterDataTable() : 
                    base("PerfmonCounter") {
                this.InitClass();
            }
            
            internal PerfmonCounterDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn PerfmonObject_IdColumn {
                get {
                    return this.columnPerfmonObject_Id;
                }
            }
            
            public PerfmonCounterRow this[int index] {
                get {
                    return ((PerfmonCounterRow)(this.Rows[index]));
                }
            }
            
            public event PerfmonCounterRowChangeEventHandler PerfmonCounterRowChanged;
            
            public event PerfmonCounterRowChangeEventHandler PerfmonCounterRowChanging;
            
            public event PerfmonCounterRowChangeEventHandler PerfmonCounterRowDeleted;
            
            public event PerfmonCounterRowChangeEventHandler PerfmonCounterRowDeleting;
            
            public void AddPerfmonCounterRow(PerfmonCounterRow row) {
                this.Rows.Add(row);
            }
            
            public PerfmonCounterRow AddPerfmonCounterRow(bool enabled, string name, PerfmonObjectRow parentPerfmonObjectRowByPerfmonObject_PerfmonCounter) {
                PerfmonCounterRow rowPerfmonCounterRow = ((PerfmonCounterRow)(this.NewRow()));
                rowPerfmonCounterRow.ItemArray = new object[] {
                        enabled,
                        name,
                        parentPerfmonObjectRowByPerfmonObject_PerfmonCounter[2]};
                this.Rows.Add(rowPerfmonCounterRow);
                return rowPerfmonCounterRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                PerfmonCounterDataTable cln = ((PerfmonCounterDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new PerfmonCounterDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnname = this.Columns["name"];
                this.columnPerfmonObject_Id = this.Columns["PerfmonObject_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columnPerfmonObject_Id = new DataColumn("PerfmonObject_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnPerfmonObject_Id);
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnname.Namespace = "";
                this.columnname.DefaultValue = "";
            }
            
            public PerfmonCounterRow NewPerfmonCounterRow() {
                return ((PerfmonCounterRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new PerfmonCounterRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(PerfmonCounterRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.PerfmonCounterRowChanged != null)) {
                    this.PerfmonCounterRowChanged(this, new PerfmonCounterRowChangeEvent(((PerfmonCounterRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.PerfmonCounterRowChanging != null)) {
                    this.PerfmonCounterRowChanging(this, new PerfmonCounterRowChangeEvent(((PerfmonCounterRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.PerfmonCounterRowDeleted != null)) {
                    this.PerfmonCounterRowDeleted(this, new PerfmonCounterRowChangeEvent(((PerfmonCounterRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.PerfmonCounterRowDeleting != null)) {
                    this.PerfmonCounterRowDeleting(this, new PerfmonCounterRowChangeEvent(((PerfmonCounterRow)(e.Row)), e.Action));
                }
            }
            
            public void RemovePerfmonCounterRow(PerfmonCounterRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCounterRow : DataRow {
            
            private PerfmonCounterDataTable tablePerfmonCounter;
            
            internal PerfmonCounterRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tablePerfmonCounter = ((PerfmonCounterDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tablePerfmonCounter.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tablePerfmonCounter.enabledColumn] = value;
                }
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tablePerfmonCounter.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tablePerfmonCounter.nameColumn] = value;
                }
            }
            
            public PerfmonObjectRow PerfmonObjectRow {
                get {
                    return ((PerfmonObjectRow)(this.GetParentRow(this.Table.ParentRelations["PerfmonObject_PerfmonCounter"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["PerfmonObject_PerfmonCounter"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tablePerfmonCounter.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tablePerfmonCounter.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tablePerfmonCounter.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tablePerfmonCounter.nameColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class PerfmonCounterRowChangeEvent : EventArgs {
            
            private PerfmonCounterRow eventRow;
            
            private DataRowAction eventAction;
            
            public PerfmonCounterRowChangeEvent(PerfmonCounterRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public PerfmonCounterRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineCollectorDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columntype;
            
            private DataColumn columnpoint;
            
            private DataColumn columnMachineCollectors_Id;
            
            internal MachineCollectorDataTable() : 
                    base("MachineCollector") {
                this.InitClass();
            }
            
            internal MachineCollectorDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn typeColumn {
                get {
                    return this.columntype;
                }
            }
            
            internal DataColumn pointColumn {
                get {
                    return this.columnpoint;
                }
            }
            
            internal DataColumn MachineCollectors_IdColumn {
                get {
                    return this.columnMachineCollectors_Id;
                }
            }
            
            public MachineCollectorRow this[int index] {
                get {
                    return ((MachineCollectorRow)(this.Rows[index]));
                }
            }
            
            public event MachineCollectorRowChangeEventHandler MachineCollectorRowChanged;
            
            public event MachineCollectorRowChangeEventHandler MachineCollectorRowChanging;
            
            public event MachineCollectorRowChangeEventHandler MachineCollectorRowDeleted;
            
            public event MachineCollectorRowChangeEventHandler MachineCollectorRowDeleting;
            
            public void AddMachineCollectorRow(MachineCollectorRow row) {
                this.Rows.Add(row);
            }
            
            public MachineCollectorRow AddMachineCollectorRow(string type, string point, MachineCollectorsRow parentMachineCollectorsRowByMachineCollectors_MachineCollector) {
                MachineCollectorRow rowMachineCollectorRow = ((MachineCollectorRow)(this.NewRow()));
                rowMachineCollectorRow.ItemArray = new object[] {
                        type,
                        point,
                        parentMachineCollectorsRowByMachineCollectors_MachineCollector[0]};
                this.Rows.Add(rowMachineCollectorRow);
                return rowMachineCollectorRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                MachineCollectorDataTable cln = ((MachineCollectorDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new MachineCollectorDataTable();
            }
            
            internal void InitVars() {
                this.columntype = this.Columns["type"];
                this.columnpoint = this.Columns["point"];
                this.columnMachineCollectors_Id = this.Columns["MachineCollectors_Id"];
            }
            
            private void InitClass() {
                this.columntype = new DataColumn("type", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columntype);
                this.columnpoint = new DataColumn("point", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnpoint);
                this.columnMachineCollectors_Id = new DataColumn("MachineCollectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachineCollectors_Id);
                this.columntype.AllowDBNull = false;
                this.columntype.Namespace = "";
                this.columnpoint.AllowDBNull = false;
                this.columnpoint.Namespace = "";
            }
            
            public MachineCollectorRow NewMachineCollectorRow() {
                return ((MachineCollectorRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new MachineCollectorRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(MachineCollectorRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.MachineCollectorRowChanged != null)) {
                    this.MachineCollectorRowChanged(this, new MachineCollectorRowChangeEvent(((MachineCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.MachineCollectorRowChanging != null)) {
                    this.MachineCollectorRowChanging(this, new MachineCollectorRowChangeEvent(((MachineCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.MachineCollectorRowDeleted != null)) {
                    this.MachineCollectorRowDeleted(this, new MachineCollectorRowChangeEvent(((MachineCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.MachineCollectorRowDeleting != null)) {
                    this.MachineCollectorRowDeleting(this, new MachineCollectorRowChangeEvent(((MachineCollectorRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveMachineCollectorRow(MachineCollectorRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineCollectorRow : DataRow {
            
            private MachineCollectorDataTable tableMachineCollector;
            
            internal MachineCollectorRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableMachineCollector = ((MachineCollectorDataTable)(this.Table));
            }
            
            public string type {
                get {
                    return ((string)(this[this.tableMachineCollector.typeColumn]));
                }
                set {
                    this[this.tableMachineCollector.typeColumn] = value;
                }
            }
            
            public string point {
                get {
                    return ((string)(this[this.tableMachineCollector.pointColumn]));
                }
                set {
                    this[this.tableMachineCollector.pointColumn] = value;
                }
            }
            
            public MachineCollectorsRow MachineCollectorsRow {
                get {
                    return ((MachineCollectorsRow)(this.GetParentRow(this.Table.ParentRelations["MachineCollectors_MachineCollector"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["MachineCollectors_MachineCollector"]);
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class MachineCollectorRowChangeEvent : EventArgs {
            
            private MachineCollectorRow eventRow;
            
            private DataRowAction eventAction;
            
            public MachineCollectorRowChangeEvent(MachineCollectorRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public MachineCollectorRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class InstancesDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnInstances_Id;
            
            private DataColumn columnMachine_Id;
            
            internal InstancesDataTable() : 
                    base("Instances") {
                this.InitClass();
            }
            
            internal InstancesDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn Instances_IdColumn {
                get {
                    return this.columnInstances_Id;
                }
            }
            
            internal DataColumn Machine_IdColumn {
                get {
                    return this.columnMachine_Id;
                }
            }
            
            public InstancesRow this[int index] {
                get {
                    return ((InstancesRow)(this.Rows[index]));
                }
            }
            
            public event InstancesRowChangeEventHandler InstancesRowChanged;
            
            public event InstancesRowChangeEventHandler InstancesRowChanging;
            
            public event InstancesRowChangeEventHandler InstancesRowDeleted;
            
            public event InstancesRowChangeEventHandler InstancesRowDeleting;
            
            public void AddInstancesRow(InstancesRow row) {
                this.Rows.Add(row);
            }
            
            public InstancesRow AddInstancesRow(MachineRow parentMachineRowByMachine_Instances) {
                InstancesRow rowInstancesRow = ((InstancesRow)(this.NewRow()));
                rowInstancesRow.ItemArray = new object[] {
                        null,
                        parentMachineRowByMachine_Instances[1]};
                this.Rows.Add(rowInstancesRow);
                return rowInstancesRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                InstancesDataTable cln = ((InstancesDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new InstancesDataTable();
            }
            
            internal void InitVars() {
                this.columnInstances_Id = this.Columns["Instances_Id"];
                this.columnMachine_Id = this.Columns["Machine_Id"];
            }
            
            private void InitClass() {
                this.columnInstances_Id = new DataColumn("Instances_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnInstances_Id);
                this.columnMachine_Id = new DataColumn("Machine_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnMachine_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnInstances_Id}, true));
                this.columnInstances_Id.AutoIncrement = true;
                this.columnInstances_Id.AllowDBNull = false;
                this.columnInstances_Id.Unique = true;
            }
            
            public InstancesRow NewInstancesRow() {
                return ((InstancesRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new InstancesRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(InstancesRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.InstancesRowChanged != null)) {
                    this.InstancesRowChanged(this, new InstancesRowChangeEvent(((InstancesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.InstancesRowChanging != null)) {
                    this.InstancesRowChanging(this, new InstancesRowChangeEvent(((InstancesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.InstancesRowDeleted != null)) {
                    this.InstancesRowDeleted(this, new InstancesRowChangeEvent(((InstancesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.InstancesRowDeleting != null)) {
                    this.InstancesRowDeleting(this, new InstancesRowChangeEvent(((InstancesRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveInstancesRow(InstancesRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class InstancesRow : DataRow {
            
            private InstancesDataTable tableInstances;
            
            internal InstancesRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableInstances = ((InstancesDataTable)(this.Table));
            }
            
            public MachineRow MachineRow {
                get {
                    return ((MachineRow)(this.GetParentRow(this.Table.ParentRelations["Machine_Instances"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Machine_Instances"]);
                }
            }
            
            public InstanceRow[] GetInstanceRows() {
                return ((InstanceRow[])(this.GetChildRows(this.Table.ChildRelations["Instances_Instance"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class InstancesRowChangeEvent : EventArgs {
            
            private InstancesRow eventRow;
            
            private DataRowAction eventAction;
            
            public InstancesRowChangeEvent(InstancesRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public InstancesRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class InstanceDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnname;
            
            private DataColumn columnwindowsauth;
            
            private DataColumn columnssver;
            
            private DataColumn columnuser;
            
            private DataColumn columnInstance_Id;
            
            private DataColumn columnInstances_Id;
            
            internal InstanceDataTable() : 
                    base("Instance") {
                this.InitClass();
            }
            
            internal InstanceDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn windowsauthColumn {
                get {
                    return this.columnwindowsauth;
                }
            }
            
            internal DataColumn ssverColumn {
                get {
                    return this.columnssver;
                }
            }
            
            internal DataColumn userColumn {
                get {
                    return this.columnuser;
                }
            }
            
            internal DataColumn Instance_IdColumn {
                get {
                    return this.columnInstance_Id;
                }
            }
            
            internal DataColumn Instances_IdColumn {
                get {
                    return this.columnInstances_Id;
                }
            }
            
            public InstanceRow this[int index] {
                get {
                    return ((InstanceRow)(this.Rows[index]));
                }
            }
            
            public event InstanceRowChangeEventHandler InstanceRowChanged;
            
            public event InstanceRowChangeEventHandler InstanceRowChanging;
            
            public event InstanceRowChangeEventHandler InstanceRowDeleted;
            
            public event InstanceRowChangeEventHandler InstanceRowDeleting;
            
            public void AddInstanceRow(InstanceRow row) {
                this.Rows.Add(row);
            }
            
            public InstanceRow AddInstanceRow(string name, bool windowsauth, int ssver, string user, InstancesRow parentInstancesRowByInstances_Instance) {
                InstanceRow rowInstanceRow = ((InstanceRow)(this.NewRow()));
                rowInstanceRow.ItemArray = new object[] {
                        name,
                        windowsauth,
                        ssver,
                        user,
                        null,
                        parentInstancesRowByInstances_Instance[0]};
                this.Rows.Add(rowInstanceRow);
                return rowInstanceRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                InstanceDataTable cln = ((InstanceDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new InstanceDataTable();
            }
            
            internal void InitVars() {
                this.columnname = this.Columns["name"];
                this.columnwindowsauth = this.Columns["windowsauth"];
                this.columnssver = this.Columns["ssver"];
                this.columnuser = this.Columns["user"];
                this.columnInstance_Id = this.Columns["Instance_Id"];
                this.columnInstances_Id = this.Columns["Instances_Id"];
            }
            
            private void InitClass() {
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columnwindowsauth = new DataColumn("windowsauth", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnwindowsauth);
                this.columnssver = new DataColumn("ssver", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnssver);
                this.columnuser = new DataColumn("user", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnuser);
                this.columnInstance_Id = new DataColumn("Instance_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnInstance_Id);
                this.columnInstances_Id = new DataColumn("Instances_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnInstances_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnInstance_Id}, true));
                this.columnname.Namespace = "";
                this.columnname.DefaultValue = "*";
                this.columnwindowsauth.Namespace = "";
                this.columnwindowsauth.DefaultValue = true;
                this.columnssver.Namespace = "";
                this.columnssver.DefaultValue = 8;
                this.columnuser.Namespace = "";
                this.columnuser.DefaultValue = "";
                this.columnInstance_Id.AutoIncrement = true;
                this.columnInstance_Id.AllowDBNull = false;
                this.columnInstance_Id.Unique = true;
            }
            
            public InstanceRow NewInstanceRow() {
                return ((InstanceRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new InstanceRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(InstanceRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.InstanceRowChanged != null)) {
                    this.InstanceRowChanged(this, new InstanceRowChangeEvent(((InstanceRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.InstanceRowChanging != null)) {
                    this.InstanceRowChanging(this, new InstanceRowChangeEvent(((InstanceRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.InstanceRowDeleted != null)) {
                    this.InstanceRowDeleted(this, new InstanceRowChangeEvent(((InstanceRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.InstanceRowDeleting != null)) {
                    this.InstanceRowDeleting(this, new InstanceRowChangeEvent(((InstanceRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveInstanceRow(InstanceRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class InstanceRow : DataRow {
            
            private InstanceDataTable tableInstance;
            
            internal InstanceRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableInstance = ((InstanceDataTable)(this.Table));
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tableInstance.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableInstance.nameColumn] = value;
                }
            }
            
            public bool windowsauth {
                get {
                    try {
                        return ((bool)(this[this.tableInstance.windowsauthColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableInstance.windowsauthColumn] = value;
                }
            }
            
            public int ssver {
                get {
                    try {
                        return ((int)(this[this.tableInstance.ssverColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableInstance.ssverColumn] = value;
                }
            }
            
            public string user {
                get {
                    try {
                        return ((string)(this[this.tableInstance.userColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableInstance.userColumn] = value;
                }
            }
            
            public InstancesRow InstancesRow {
                get {
                    return ((InstancesRow)(this.GetParentRow(this.Table.ParentRelations["Instances_Instance"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Instances_Instance"]);
                }
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tableInstance.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tableInstance.nameColumn] = System.Convert.DBNull;
            }
            
            public bool IswindowsauthNull() {
                return this.IsNull(this.tableInstance.windowsauthColumn);
            }
            
            public void SetwindowsauthNull() {
                this[this.tableInstance.windowsauthColumn] = System.Convert.DBNull;
            }
            
            public bool IsssverNull() {
                return this.IsNull(this.tableInstance.ssverColumn);
            }
            
            public void SetssverNull() {
                this[this.tableInstance.ssverColumn] = System.Convert.DBNull;
            }
            
            public bool IsuserNull() {
                return this.IsNull(this.tableInstance.userColumn);
            }
            
            public void SetuserNull() {
                this[this.tableInstance.userColumn] = System.Convert.DBNull;
            }
            
            public CollectorsRow[] GetCollectorsRows() {
                return ((CollectorsRow[])(this.GetChildRows(this.Table.ChildRelations["Instance_Collectors"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class InstanceRowChangeEvent : EventArgs {
            
            private InstanceRow eventRow;
            
            private DataRowAction eventAction;
            
            public InstanceRowChangeEvent(InstanceRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public InstanceRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectorsDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnCollectors_Id;
            
            private DataColumn columnInstance_Id;
            
            internal CollectorsDataTable() : 
                    base("Collectors") {
                this.InitClass();
            }
            
            internal CollectorsDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn Collectors_IdColumn {
                get {
                    return this.columnCollectors_Id;
                }
            }
            
            internal DataColumn Instance_IdColumn {
                get {
                    return this.columnInstance_Id;
                }
            }
            
            public CollectorsRow this[int index] {
                get {
                    return ((CollectorsRow)(this.Rows[index]));
                }
            }
            
            public event CollectorsRowChangeEventHandler CollectorsRowChanged;
            
            public event CollectorsRowChangeEventHandler CollectorsRowChanging;
            
            public event CollectorsRowChangeEventHandler CollectorsRowDeleted;
            
            public event CollectorsRowChangeEventHandler CollectorsRowDeleting;
            
            public void AddCollectorsRow(CollectorsRow row) {
                this.Rows.Add(row);
            }
            
            public CollectorsRow AddCollectorsRow(InstanceRow parentInstanceRowByInstance_Collectors) {
                CollectorsRow rowCollectorsRow = ((CollectorsRow)(this.NewRow()));
                rowCollectorsRow.ItemArray = new object[] {
                        null,
                        parentInstanceRowByInstance_Collectors[4]};
                this.Rows.Add(rowCollectorsRow);
                return rowCollectorsRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                CollectorsDataTable cln = ((CollectorsDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new CollectorsDataTable();
            }
            
            internal void InitVars() {
                this.columnCollectors_Id = this.Columns["Collectors_Id"];
                this.columnInstance_Id = this.Columns["Instance_Id"];
            }
            
            private void InitClass() {
                this.columnCollectors_Id = new DataColumn("Collectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollectors_Id);
                this.columnInstance_Id = new DataColumn("Instance_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnInstance_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnCollectors_Id}, true));
                this.columnCollectors_Id.AutoIncrement = true;
                this.columnCollectors_Id.AllowDBNull = false;
                this.columnCollectors_Id.Unique = true;
            }
            
            public CollectorsRow NewCollectorsRow() {
                return ((CollectorsRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new CollectorsRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(CollectorsRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.CollectorsRowChanged != null)) {
                    this.CollectorsRowChanged(this, new CollectorsRowChangeEvent(((CollectorsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.CollectorsRowChanging != null)) {
                    this.CollectorsRowChanging(this, new CollectorsRowChangeEvent(((CollectorsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.CollectorsRowDeleted != null)) {
                    this.CollectorsRowDeleted(this, new CollectorsRowChangeEvent(((CollectorsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.CollectorsRowDeleting != null)) {
                    this.CollectorsRowDeleting(this, new CollectorsRowChangeEvent(((CollectorsRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveCollectorsRow(CollectorsRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectorsRow : DataRow {
            
            private CollectorsDataTable tableCollectors;
            
            internal CollectorsRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableCollectors = ((CollectorsDataTable)(this.Table));
            }
            
            public InstanceRow InstanceRow {
                get {
                    return ((InstanceRow)(this.GetParentRow(this.Table.ParentRelations["Instance_Collectors"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Instance_Collectors"]);
                }
            }
            
            public SqldiagCollectorRow[] GetSqldiagCollectorRows() {
                return ((SqldiagCollectorRow[])(this.GetChildRows(this.Table.ChildRelations["Collectors_SqldiagCollector"])));
            }
            
            public BlockingCollectorRow[] GetBlockingCollectorRows() {
                return ((BlockingCollectorRow[])(this.GetChildRows(this.Table.ChildRelations["Collectors_BlockingCollector"])));
            }
            
            public ProfilerCollectorRow[] GetProfilerCollectorRows() {
                return ((ProfilerCollectorRow[])(this.GetChildRows(this.Table.ChildRelations["Collectors_ProfilerCollector"])));
            }
            
            public CollectorRow[] GetCollectorRows() {
                return ((CollectorRow[])(this.GetChildRows(this.Table.ChildRelations["Collectors_Collector"])));
            }
            
            public CustomDiagGroupRow[] GetCustomDiagGroupRows() {
                return ((CustomDiagGroupRow[])(this.GetChildRows(this.Table.ChildRelations["Collectors_CustomDiagGroup"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectorsRowChangeEvent : EventArgs {
            
            private CollectorsRow eventRow;
            
            private DataRowAction eventAction;
            
            public CollectorsRowChangeEvent(CollectorsRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public CollectorsRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class SqldiagCollectorDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnstartup;
            
            private DataColumn columnshutdown;
            
            private DataColumn columnCollectors_Id;
            
            internal SqldiagCollectorDataTable() : 
                    base("SqldiagCollector") {
                this.InitClass();
            }
            
            internal SqldiagCollectorDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn startupColumn {
                get {
                    return this.columnstartup;
                }
            }
            
            internal DataColumn shutdownColumn {
                get {
                    return this.columnshutdown;
                }
            }
            
            internal DataColumn Collectors_IdColumn {
                get {
                    return this.columnCollectors_Id;
                }
            }
            
            public SqldiagCollectorRow this[int index] {
                get {
                    return ((SqldiagCollectorRow)(this.Rows[index]));
                }
            }
            
            public event SqldiagCollectorRowChangeEventHandler SqldiagCollectorRowChanged;
            
            public event SqldiagCollectorRowChangeEventHandler SqldiagCollectorRowChanging;
            
            public event SqldiagCollectorRowChangeEventHandler SqldiagCollectorRowDeleted;
            
            public event SqldiagCollectorRowChangeEventHandler SqldiagCollectorRowDeleting;
            
            public void AddSqldiagCollectorRow(SqldiagCollectorRow row) {
                this.Rows.Add(row);
            }
            
            public SqldiagCollectorRow AddSqldiagCollectorRow(bool enabled, bool startup, bool shutdown, CollectorsRow parentCollectorsRowByCollectors_SqldiagCollector) {
                SqldiagCollectorRow rowSqldiagCollectorRow = ((SqldiagCollectorRow)(this.NewRow()));
                rowSqldiagCollectorRow.ItemArray = new object[] {
                        enabled,
                        startup,
                        shutdown,
                        parentCollectorsRowByCollectors_SqldiagCollector[0]};
                this.Rows.Add(rowSqldiagCollectorRow);
                return rowSqldiagCollectorRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                SqldiagCollectorDataTable cln = ((SqldiagCollectorDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new SqldiagCollectorDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnstartup = this.Columns["startup"];
                this.columnshutdown = this.Columns["shutdown"];
                this.columnCollectors_Id = this.Columns["Collectors_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnstartup = new DataColumn("startup", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnstartup);
                this.columnshutdown = new DataColumn("shutdown", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnshutdown);
                this.columnCollectors_Id = new DataColumn("Collectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollectors_Id);
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnstartup.Namespace = "";
                this.columnstartup.DefaultValue = false;
                this.columnshutdown.Namespace = "";
                this.columnshutdown.DefaultValue = false;
            }
            
            public SqldiagCollectorRow NewSqldiagCollectorRow() {
                return ((SqldiagCollectorRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new SqldiagCollectorRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(SqldiagCollectorRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.SqldiagCollectorRowChanged != null)) {
                    this.SqldiagCollectorRowChanged(this, new SqldiagCollectorRowChangeEvent(((SqldiagCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.SqldiagCollectorRowChanging != null)) {
                    this.SqldiagCollectorRowChanging(this, new SqldiagCollectorRowChangeEvent(((SqldiagCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.SqldiagCollectorRowDeleted != null)) {
                    this.SqldiagCollectorRowDeleted(this, new SqldiagCollectorRowChangeEvent(((SqldiagCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.SqldiagCollectorRowDeleting != null)) {
                    this.SqldiagCollectorRowDeleting(this, new SqldiagCollectorRowChangeEvent(((SqldiagCollectorRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveSqldiagCollectorRow(SqldiagCollectorRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class SqldiagCollectorRow : DataRow {
            
            private SqldiagCollectorDataTable tableSqldiagCollector;
            
            internal SqldiagCollectorRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableSqldiagCollector = ((SqldiagCollectorDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableSqldiagCollector.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableSqldiagCollector.enabledColumn] = value;
                }
            }
            
            public bool startup {
                get {
                    try {
                        return ((bool)(this[this.tableSqldiagCollector.startupColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableSqldiagCollector.startupColumn] = value;
                }
            }
            
            public bool shutdown {
                get {
                    try {
                        return ((bool)(this[this.tableSqldiagCollector.shutdownColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableSqldiagCollector.shutdownColumn] = value;
                }
            }
            
            public CollectorsRow CollectorsRow {
                get {
                    return ((CollectorsRow)(this.GetParentRow(this.Table.ParentRelations["Collectors_SqldiagCollector"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Collectors_SqldiagCollector"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableSqldiagCollector.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableSqldiagCollector.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsstartupNull() {
                return this.IsNull(this.tableSqldiagCollector.startupColumn);
            }
            
            public void SetstartupNull() {
                this[this.tableSqldiagCollector.startupColumn] = System.Convert.DBNull;
            }
            
            public bool IsshutdownNull() {
                return this.IsNull(this.tableSqldiagCollector.shutdownColumn);
            }
            
            public void SetshutdownNull() {
                this[this.tableSqldiagCollector.shutdownColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class SqldiagCollectorRowChangeEvent : EventArgs {
            
            private SqldiagCollectorRow eventRow;
            
            private DataRowAction eventAction;
            
            public SqldiagCollectorRowChangeEvent(SqldiagCollectorRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public SqldiagCollectorRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class BlockingCollectorDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnlatch;
            
            private DataColumn columnfast;
            
            private DataColumn columnpollinginterval;
            
            private DataColumn columnCollectors_Id;
            
            internal BlockingCollectorDataTable() : 
                    base("BlockingCollector") {
                this.InitClass();
            }
            
            internal BlockingCollectorDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn latchColumn {
                get {
                    return this.columnlatch;
                }
            }
            
            internal DataColumn fastColumn {
                get {
                    return this.columnfast;
                }
            }
            
            internal DataColumn pollingintervalColumn {
                get {
                    return this.columnpollinginterval;
                }
            }
            
            internal DataColumn Collectors_IdColumn {
                get {
                    return this.columnCollectors_Id;
                }
            }
            
            public BlockingCollectorRow this[int index] {
                get {
                    return ((BlockingCollectorRow)(this.Rows[index]));
                }
            }
            
            public event BlockingCollectorRowChangeEventHandler BlockingCollectorRowChanged;
            
            public event BlockingCollectorRowChangeEventHandler BlockingCollectorRowChanging;
            
            public event BlockingCollectorRowChangeEventHandler BlockingCollectorRowDeleted;
            
            public event BlockingCollectorRowChangeEventHandler BlockingCollectorRowDeleting;
            
            public void AddBlockingCollectorRow(BlockingCollectorRow row) {
                this.Rows.Add(row);
            }
            
            public BlockingCollectorRow AddBlockingCollectorRow(bool enabled, bool latch, bool fast, int pollinginterval, CollectorsRow parentCollectorsRowByCollectors_BlockingCollector) {
                BlockingCollectorRow rowBlockingCollectorRow = ((BlockingCollectorRow)(this.NewRow()));
                rowBlockingCollectorRow.ItemArray = new object[] {
                        enabled,
                        latch,
                        fast,
                        pollinginterval,
                        parentCollectorsRowByCollectors_BlockingCollector[0]};
                this.Rows.Add(rowBlockingCollectorRow);
                return rowBlockingCollectorRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                BlockingCollectorDataTable cln = ((BlockingCollectorDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new BlockingCollectorDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnlatch = this.Columns["latch"];
                this.columnfast = this.Columns["fast"];
                this.columnpollinginterval = this.Columns["pollinginterval"];
                this.columnCollectors_Id = this.Columns["Collectors_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnlatch = new DataColumn("latch", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnlatch);
                this.columnfast = new DataColumn("fast", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnfast);
                this.columnpollinginterval = new DataColumn("pollinginterval", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnpollinginterval);
                this.columnCollectors_Id = new DataColumn("Collectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollectors_Id);
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnlatch.Namespace = "";
                this.columnlatch.DefaultValue = false;
                this.columnfast.Namespace = "";
                this.columnfast.DefaultValue = true;
                this.columnpollinginterval.Namespace = "";
                this.columnpollinginterval.DefaultValue = 5;
            }
            
            public BlockingCollectorRow NewBlockingCollectorRow() {
                return ((BlockingCollectorRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new BlockingCollectorRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(BlockingCollectorRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.BlockingCollectorRowChanged != null)) {
                    this.BlockingCollectorRowChanged(this, new BlockingCollectorRowChangeEvent(((BlockingCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.BlockingCollectorRowChanging != null)) {
                    this.BlockingCollectorRowChanging(this, new BlockingCollectorRowChangeEvent(((BlockingCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.BlockingCollectorRowDeleted != null)) {
                    this.BlockingCollectorRowDeleted(this, new BlockingCollectorRowChangeEvent(((BlockingCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.BlockingCollectorRowDeleting != null)) {
                    this.BlockingCollectorRowDeleting(this, new BlockingCollectorRowChangeEvent(((BlockingCollectorRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveBlockingCollectorRow(BlockingCollectorRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class BlockingCollectorRow : DataRow {
            
            private BlockingCollectorDataTable tableBlockingCollector;
            
            internal BlockingCollectorRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableBlockingCollector = ((BlockingCollectorDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableBlockingCollector.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableBlockingCollector.enabledColumn] = value;
                }
            }
            
            public bool latch {
                get {
                    try {
                        return ((bool)(this[this.tableBlockingCollector.latchColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableBlockingCollector.latchColumn] = value;
                }
            }
            
            public bool fast {
                get {
                    try {
                        return ((bool)(this[this.tableBlockingCollector.fastColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableBlockingCollector.fastColumn] = value;
                }
            }
            
            public int pollinginterval {
                get {
                    try {
                        return ((int)(this[this.tableBlockingCollector.pollingintervalColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableBlockingCollector.pollingintervalColumn] = value;
                }
            }
            
            public CollectorsRow CollectorsRow {
                get {
                    return ((CollectorsRow)(this.GetParentRow(this.Table.ParentRelations["Collectors_BlockingCollector"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Collectors_BlockingCollector"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableBlockingCollector.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableBlockingCollector.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IslatchNull() {
                return this.IsNull(this.tableBlockingCollector.latchColumn);
            }
            
            public void SetlatchNull() {
                this[this.tableBlockingCollector.latchColumn] = System.Convert.DBNull;
            }
            
            public bool IsfastNull() {
                return this.IsNull(this.tableBlockingCollector.fastColumn);
            }
            
            public void SetfastNull() {
                this[this.tableBlockingCollector.fastColumn] = System.Convert.DBNull;
            }
            
            public bool IspollingintervalNull() {
                return this.IsNull(this.tableBlockingCollector.pollingintervalColumn);
            }
            
            public void SetpollingintervalNull() {
                this[this.tableBlockingCollector.pollingintervalColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class BlockingCollectorRowChangeEvent : EventArgs {
            
            private BlockingCollectorRow eventRow;
            
            private DataRowAction eventAction;
            
            public BlockingCollectorRowChangeEvent(BlockingCollectorRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public BlockingCollectorRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class ProfilerCollectorDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columntemplate;
            
            private DataColumn columnpollinginterval;
            
            private DataColumn columnmaxprofilerfilesize;
            
            private DataColumn columnProfilerCollector_Id;
            
            private DataColumn columnCollectors_Id;
            
            internal ProfilerCollectorDataTable() : 
                    base("ProfilerCollector") {
                this.InitClass();
            }
            
            internal ProfilerCollectorDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn templateColumn {
                get {
                    return this.columntemplate;
                }
            }
            
            internal DataColumn pollingintervalColumn {
                get {
                    return this.columnpollinginterval;
                }
            }
            
            internal DataColumn maxprofilerfilesizeColumn {
                get {
                    return this.columnmaxprofilerfilesize;
                }
            }
            
            internal DataColumn ProfilerCollector_IdColumn {
                get {
                    return this.columnProfilerCollector_Id;
                }
            }
            
            internal DataColumn Collectors_IdColumn {
                get {
                    return this.columnCollectors_Id;
                }
            }
            
            public ProfilerCollectorRow this[int index] {
                get {
                    return ((ProfilerCollectorRow)(this.Rows[index]));
                }
            }
            
            public event ProfilerCollectorRowChangeEventHandler ProfilerCollectorRowChanged;
            
            public event ProfilerCollectorRowChangeEventHandler ProfilerCollectorRowChanging;
            
            public event ProfilerCollectorRowChangeEventHandler ProfilerCollectorRowDeleted;
            
            public event ProfilerCollectorRowChangeEventHandler ProfilerCollectorRowDeleting;
            
            public void AddProfilerCollectorRow(ProfilerCollectorRow row) {
                this.Rows.Add(row);
            }
            
            public ProfilerCollectorRow AddProfilerCollectorRow(bool enabled, string template, int pollinginterval, int maxprofilerfilesize, CollectorsRow parentCollectorsRowByCollectors_ProfilerCollector) {
                ProfilerCollectorRow rowProfilerCollectorRow = ((ProfilerCollectorRow)(this.NewRow()));
                rowProfilerCollectorRow.ItemArray = new object[] {
                        enabled,
                        template,
                        pollinginterval,
                        maxprofilerfilesize,
                        null,
                        parentCollectorsRowByCollectors_ProfilerCollector[0]};
                this.Rows.Add(rowProfilerCollectorRow);
                return rowProfilerCollectorRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                ProfilerCollectorDataTable cln = ((ProfilerCollectorDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new ProfilerCollectorDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columntemplate = this.Columns["template"];
                this.columnpollinginterval = this.Columns["pollinginterval"];
                this.columnmaxprofilerfilesize = this.Columns["maxprofilerfilesize"];
                this.columnProfilerCollector_Id = this.Columns["ProfilerCollector_Id"];
                this.columnCollectors_Id = this.Columns["Collectors_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columntemplate = new DataColumn("template", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columntemplate);
                this.columnpollinginterval = new DataColumn("pollinginterval", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnpollinginterval);
                this.columnmaxprofilerfilesize = new DataColumn("maxprofilerfilesize", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnmaxprofilerfilesize);
                this.columnProfilerCollector_Id = new DataColumn("ProfilerCollector_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnProfilerCollector_Id);
                this.columnCollectors_Id = new DataColumn("Collectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollectors_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnProfilerCollector_Id}, true));
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columntemplate.Namespace = "";
                this.columntemplate.DefaultValue = "_GeneralPerformance80.TTD";
                this.columnpollinginterval.Namespace = "";
                this.columnpollinginterval.DefaultValue = 5;
                this.columnmaxprofilerfilesize.Namespace = "";
                this.columnmaxprofilerfilesize.DefaultValue = 350;
                this.columnProfilerCollector_Id.AutoIncrement = true;
                this.columnProfilerCollector_Id.AllowDBNull = false;
                this.columnProfilerCollector_Id.Unique = true;
            }
            
            public ProfilerCollectorRow NewProfilerCollectorRow() {
                return ((ProfilerCollectorRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new ProfilerCollectorRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(ProfilerCollectorRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.ProfilerCollectorRowChanged != null)) {
                    this.ProfilerCollectorRowChanged(this, new ProfilerCollectorRowChangeEvent(((ProfilerCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.ProfilerCollectorRowChanging != null)) {
                    this.ProfilerCollectorRowChanging(this, new ProfilerCollectorRowChangeEvent(((ProfilerCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.ProfilerCollectorRowDeleted != null)) {
                    this.ProfilerCollectorRowDeleted(this, new ProfilerCollectorRowChangeEvent(((ProfilerCollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.ProfilerCollectorRowDeleting != null)) {
                    this.ProfilerCollectorRowDeleting(this, new ProfilerCollectorRowChangeEvent(((ProfilerCollectorRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveProfilerCollectorRow(ProfilerCollectorRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class ProfilerCollectorRow : DataRow {
            
            private ProfilerCollectorDataTable tableProfilerCollector;
            
            internal ProfilerCollectorRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableProfilerCollector = ((ProfilerCollectorDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableProfilerCollector.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableProfilerCollector.enabledColumn] = value;
                }
            }
            
            public string template {
                get {
                    try {
                        return ((string)(this[this.tableProfilerCollector.templateColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableProfilerCollector.templateColumn] = value;
                }
            }
            
            public int pollinginterval {
                get {
                    try {
                        return ((int)(this[this.tableProfilerCollector.pollingintervalColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableProfilerCollector.pollingintervalColumn] = value;
                }
            }
            
            public int maxprofilerfilesize {
                get {
                    try {
                        return ((int)(this[this.tableProfilerCollector.maxprofilerfilesizeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableProfilerCollector.maxprofilerfilesizeColumn] = value;
                }
            }
            
            public CollectorsRow CollectorsRow {
                get {
                    return ((CollectorsRow)(this.GetParentRow(this.Table.ParentRelations["Collectors_ProfilerCollector"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Collectors_ProfilerCollector"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableProfilerCollector.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableProfilerCollector.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IstemplateNull() {
                return this.IsNull(this.tableProfilerCollector.templateColumn);
            }
            
            public void SettemplateNull() {
                this[this.tableProfilerCollector.templateColumn] = System.Convert.DBNull;
            }
            
            public bool IspollingintervalNull() {
                return this.IsNull(this.tableProfilerCollector.pollingintervalColumn);
            }
            
            public void SetpollingintervalNull() {
                this[this.tableProfilerCollector.pollingintervalColumn] = System.Convert.DBNull;
            }
            
            public bool IsmaxprofilerfilesizeNull() {
                return this.IsNull(this.tableProfilerCollector.maxprofilerfilesizeColumn);
            }
            
            public void SetmaxprofilerfilesizeNull() {
                this[this.tableProfilerCollector.maxprofilerfilesizeColumn] = System.Convert.DBNull;
            }
            
            public EventsRow[] GetEventsRows() {
                return ((EventsRow[])(this.GetChildRows(this.Table.ChildRelations["ProfilerCollector_Events"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class ProfilerCollectorRowChangeEvent : EventArgs {
            
            private ProfilerCollectorRow eventRow;
            
            private DataRowAction eventAction;
            
            public ProfilerCollectorRowChangeEvent(ProfilerCollectorRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public ProfilerCollectorRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventsDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnEvents_Id;
            
            private DataColumn columnProfilerCollector_Id;
            
            internal EventsDataTable() : 
                    base("Events") {
                this.InitClass();
            }
            
            internal EventsDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn Events_IdColumn {
                get {
                    return this.columnEvents_Id;
                }
            }
            
            internal DataColumn ProfilerCollector_IdColumn {
                get {
                    return this.columnProfilerCollector_Id;
                }
            }
            
            public EventsRow this[int index] {
                get {
                    return ((EventsRow)(this.Rows[index]));
                }
            }
            
            public event EventsRowChangeEventHandler EventsRowChanged;
            
            public event EventsRowChangeEventHandler EventsRowChanging;
            
            public event EventsRowChangeEventHandler EventsRowDeleted;
            
            public event EventsRowChangeEventHandler EventsRowDeleting;
            
            public void AddEventsRow(EventsRow row) {
                this.Rows.Add(row);
            }
            
            public EventsRow AddEventsRow(ProfilerCollectorRow parentProfilerCollectorRowByProfilerCollector_Events) {
                EventsRow rowEventsRow = ((EventsRow)(this.NewRow()));
                rowEventsRow.ItemArray = new object[] {
                        null,
                        parentProfilerCollectorRowByProfilerCollector_Events[4]};
                this.Rows.Add(rowEventsRow);
                return rowEventsRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                EventsDataTable cln = ((EventsDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new EventsDataTable();
            }
            
            internal void InitVars() {
                this.columnEvents_Id = this.Columns["Events_Id"];
                this.columnProfilerCollector_Id = this.Columns["ProfilerCollector_Id"];
            }
            
            private void InitClass() {
                this.columnEvents_Id = new DataColumn("Events_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnEvents_Id);
                this.columnProfilerCollector_Id = new DataColumn("ProfilerCollector_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnProfilerCollector_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnEvents_Id}, true));
                this.columnEvents_Id.AutoIncrement = true;
                this.columnEvents_Id.AllowDBNull = false;
                this.columnEvents_Id.Unique = true;
            }
            
            public EventsRow NewEventsRow() {
                return ((EventsRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new EventsRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(EventsRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.EventsRowChanged != null)) {
                    this.EventsRowChanged(this, new EventsRowChangeEvent(((EventsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.EventsRowChanging != null)) {
                    this.EventsRowChanging(this, new EventsRowChangeEvent(((EventsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.EventsRowDeleted != null)) {
                    this.EventsRowDeleted(this, new EventsRowChangeEvent(((EventsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.EventsRowDeleting != null)) {
                    this.EventsRowDeleting(this, new EventsRowChangeEvent(((EventsRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveEventsRow(EventsRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventsRow : DataRow {
            
            private EventsDataTable tableEvents;
            
            internal EventsRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableEvents = ((EventsDataTable)(this.Table));
            }
            
            public ProfilerCollectorRow ProfilerCollectorRow {
                get {
                    return ((ProfilerCollectorRow)(this.GetParentRow(this.Table.ParentRelations["ProfilerCollector_Events"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["ProfilerCollector_Events"]);
                }
            }
            
            public EventTypeRow[] GetEventTypeRows() {
                return ((EventTypeRow[])(this.GetChildRows(this.Table.ChildRelations["Events_EventType"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventsRowChangeEvent : EventArgs {
            
            private EventsRow eventRow;
            
            private DataRowAction eventAction;
            
            public EventsRowChangeEvent(EventsRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public EventsRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventTypeDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnname;
            
            private DataColumn columnEventType_Id;
            
            private DataColumn columnEvents_Id;
            
            internal EventTypeDataTable() : 
                    base("EventType") {
                this.InitClass();
            }
            
            internal EventTypeDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn EventType_IdColumn {
                get {
                    return this.columnEventType_Id;
                }
            }
            
            internal DataColumn Events_IdColumn {
                get {
                    return this.columnEvents_Id;
                }
            }
            
            public EventTypeRow this[int index] {
                get {
                    return ((EventTypeRow)(this.Rows[index]));
                }
            }
            
            public event EventTypeRowChangeEventHandler EventTypeRowChanged;
            
            public event EventTypeRowChangeEventHandler EventTypeRowChanging;
            
            public event EventTypeRowChangeEventHandler EventTypeRowDeleted;
            
            public event EventTypeRowChangeEventHandler EventTypeRowDeleting;
            
            public void AddEventTypeRow(EventTypeRow row) {
                this.Rows.Add(row);
            }
            
            public EventTypeRow AddEventTypeRow(bool enabled, string name, EventsRow parentEventsRowByEvents_EventType) {
                EventTypeRow rowEventTypeRow = ((EventTypeRow)(this.NewRow()));
                rowEventTypeRow.ItemArray = new object[] {
                        enabled,
                        name,
                        null,
                        parentEventsRowByEvents_EventType[0]};
                this.Rows.Add(rowEventTypeRow);
                return rowEventTypeRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                EventTypeDataTable cln = ((EventTypeDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new EventTypeDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnname = this.Columns["name"];
                this.columnEventType_Id = this.Columns["EventType_Id"];
                this.columnEvents_Id = this.Columns["Events_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columnEventType_Id = new DataColumn("EventType_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnEventType_Id);
                this.columnEvents_Id = new DataColumn("Events_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnEvents_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnEventType_Id}, true));
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnname.Namespace = "";
                this.columnname.DefaultValue = "";
                this.columnEventType_Id.AutoIncrement = true;
                this.columnEventType_Id.AllowDBNull = false;
                this.columnEventType_Id.Unique = true;
            }
            
            public EventTypeRow NewEventTypeRow() {
                return ((EventTypeRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new EventTypeRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(EventTypeRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.EventTypeRowChanged != null)) {
                    this.EventTypeRowChanged(this, new EventTypeRowChangeEvent(((EventTypeRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.EventTypeRowChanging != null)) {
                    this.EventTypeRowChanging(this, new EventTypeRowChangeEvent(((EventTypeRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.EventTypeRowDeleted != null)) {
                    this.EventTypeRowDeleted(this, new EventTypeRowChangeEvent(((EventTypeRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.EventTypeRowDeleting != null)) {
                    this.EventTypeRowDeleting(this, new EventTypeRowChangeEvent(((EventTypeRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveEventTypeRow(EventTypeRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventTypeRow : DataRow {
            
            private EventTypeDataTable tableEventType;
            
            internal EventTypeRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableEventType = ((EventTypeDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableEventType.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEventType.enabledColumn] = value;
                }
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tableEventType.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEventType.nameColumn] = value;
                }
            }
            
            public EventsRow EventsRow {
                get {
                    return ((EventsRow)(this.GetParentRow(this.Table.ParentRelations["Events_EventType"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Events_EventType"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableEventType.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableEventType.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tableEventType.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tableEventType.nameColumn] = System.Convert.DBNull;
            }
            
            public EventRow[] GetEventRows() {
                return ((EventRow[])(this.GetChildRows(this.Table.ChildRelations["EventType_Event"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventTypeRowChangeEvent : EventArgs {
            
            private EventTypeRow eventRow;
            
            private DataRowAction eventAction;
            
            public EventTypeRowChangeEvent(EventTypeRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public EventTypeRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnname;
            
            private DataColumn columndescription;
            
            private DataColumn columnid;
            
            private DataColumn columnEventType_Id;
            
            internal EventDataTable() : 
                    base("Event") {
                this.InitClass();
            }
            
            internal EventDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn descriptionColumn {
                get {
                    return this.columndescription;
                }
            }
            
            internal DataColumn idColumn {
                get {
                    return this.columnid;
                }
            }
            
            internal DataColumn EventType_IdColumn {
                get {
                    return this.columnEventType_Id;
                }
            }
            
            public EventRow this[int index] {
                get {
                    return ((EventRow)(this.Rows[index]));
                }
            }
            
            public event EventRowChangeEventHandler EventRowChanged;
            
            public event EventRowChangeEventHandler EventRowChanging;
            
            public event EventRowChangeEventHandler EventRowDeleted;
            
            public event EventRowChangeEventHandler EventRowDeleting;
            
            public void AddEventRow(EventRow row) {
                this.Rows.Add(row);
            }
            
            public EventRow AddEventRow(bool enabled, string name, string description, int id, EventTypeRow parentEventTypeRowByEventType_Event) {
                EventRow rowEventRow = ((EventRow)(this.NewRow()));
                rowEventRow.ItemArray = new object[] {
                        enabled,
                        name,
                        description,
                        id,
                        parentEventTypeRowByEventType_Event[2]};
                this.Rows.Add(rowEventRow);
                return rowEventRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                EventDataTable cln = ((EventDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new EventDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnname = this.Columns["name"];
                this.columndescription = this.Columns["description"];
                this.columnid = this.Columns["id"];
                this.columnEventType_Id = this.Columns["EventType_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columndescription = new DataColumn("description", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columndescription);
                this.columnid = new DataColumn("id", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnid);
                this.columnEventType_Id = new DataColumn("EventType_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnEventType_Id);
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnname.Namespace = "";
                this.columnname.DefaultValue = "";
                this.columndescription.Namespace = "";
                this.columndescription.DefaultValue = "";
                this.columnid.Namespace = "";
                this.columnid.DefaultValue = 0;
            }
            
            public EventRow NewEventRow() {
                return ((EventRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new EventRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(EventRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.EventRowChanged != null)) {
                    this.EventRowChanged(this, new EventRowChangeEvent(((EventRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.EventRowChanging != null)) {
                    this.EventRowChanging(this, new EventRowChangeEvent(((EventRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.EventRowDeleted != null)) {
                    this.EventRowDeleted(this, new EventRowChangeEvent(((EventRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.EventRowDeleting != null)) {
                    this.EventRowDeleting(this, new EventRowChangeEvent(((EventRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveEventRow(EventRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventRow : DataRow {
            
            private EventDataTable tableEvent;
            
            internal EventRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableEvent = ((EventDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableEvent.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEvent.enabledColumn] = value;
                }
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tableEvent.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEvent.nameColumn] = value;
                }
            }
            
            public string description {
                get {
                    try {
                        return ((string)(this[this.tableEvent.descriptionColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEvent.descriptionColumn] = value;
                }
            }
            
            public int id {
                get {
                    try {
                        return ((int)(this[this.tableEvent.idColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableEvent.idColumn] = value;
                }
            }
            
            public EventTypeRow EventTypeRow {
                get {
                    return ((EventTypeRow)(this.GetParentRow(this.Table.ParentRelations["EventType_Event"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["EventType_Event"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableEvent.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableEvent.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tableEvent.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tableEvent.nameColumn] = System.Convert.DBNull;
            }
            
            public bool IsdescriptionNull() {
                return this.IsNull(this.tableEvent.descriptionColumn);
            }
            
            public void SetdescriptionNull() {
                this[this.tableEvent.descriptionColumn] = System.Convert.DBNull;
            }
            
            public bool IsidNull() {
                return this.IsNull(this.tableEvent.idColumn);
            }
            
            public void SetidNull() {
                this[this.tableEvent.idColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class EventRowChangeEvent : EventArgs {
            
            private EventRow eventRow;
            
            private DataRowAction eventAction;
            
            public EventRowChangeEvent(EventRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public EventRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectorDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columntype;
            
            private DataColumn columnpoint;
            
            private DataColumn columncmd;
            
            private DataColumn columngroupname;
            
            private DataColumn columntaskname;
            
            private DataColumn columncustomdiagtype;
            
            private DataColumn columnwait;
            
            private DataColumn columnCollectors_Id;
            
            internal CollectorDataTable() : 
                    base("Collector") {
                this.InitClass();
            }
            
            internal CollectorDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn typeColumn {
                get {
                    return this.columntype;
                }
            }
            
            internal DataColumn pointColumn {
                get {
                    return this.columnpoint;
                }
            }
            
            internal DataColumn cmdColumn {
                get {
                    return this.columncmd;
                }
            }
            
            internal DataColumn groupnameColumn {
                get {
                    return this.columngroupname;
                }
            }
            
            internal DataColumn tasknameColumn {
                get {
                    return this.columntaskname;
                }
            }
            
            internal DataColumn customdiagtypeColumn {
                get {
                    return this.columncustomdiagtype;
                }
            }
            
            internal DataColumn waitColumn {
                get {
                    return this.columnwait;
                }
            }
            
            internal DataColumn Collectors_IdColumn {
                get {
                    return this.columnCollectors_Id;
                }
            }
            
            public CollectorRow this[int index] {
                get {
                    return ((CollectorRow)(this.Rows[index]));
                }
            }
            
            public event CollectorRowChangeEventHandler CollectorRowChanged;
            
            public event CollectorRowChangeEventHandler CollectorRowChanging;
            
            public event CollectorRowChangeEventHandler CollectorRowDeleted;
            
            public event CollectorRowChangeEventHandler CollectorRowDeleting;
            
            public void AddCollectorRow(CollectorRow row) {
                this.Rows.Add(row);
            }
            
            public CollectorRow AddCollectorRow(bool enabled, string type, string point, string cmd, string groupname, string taskname, string customdiagtype, string wait, CollectorsRow parentCollectorsRowByCollectors_Collector) {
                CollectorRow rowCollectorRow = ((CollectorRow)(this.NewRow()));
                rowCollectorRow.ItemArray = new object[] {
                        enabled,
                        type,
                        point,
                        cmd,
                        groupname,
                        taskname,
                        customdiagtype,
                        wait,
                        parentCollectorsRowByCollectors_Collector[0]};
                this.Rows.Add(rowCollectorRow);
                return rowCollectorRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                CollectorDataTable cln = ((CollectorDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new CollectorDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columntype = this.Columns["type"];
                this.columnpoint = this.Columns["point"];
                this.columncmd = this.Columns["cmd"];
                this.columngroupname = this.Columns["groupname"];
                this.columntaskname = this.Columns["taskname"];
                this.columncustomdiagtype = this.Columns["customdiagtype"];
                this.columnwait = this.Columns["wait"];
                this.columnCollectors_Id = this.Columns["Collectors_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columntype = new DataColumn("type", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columntype);
                this.columnpoint = new DataColumn("point", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnpoint);
                this.columncmd = new DataColumn("cmd", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columncmd);
                this.columngroupname = new DataColumn("groupname", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columngroupname);
                this.columntaskname = new DataColumn("taskname", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columntaskname);
                this.columncustomdiagtype = new DataColumn("customdiagtype", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columncustomdiagtype);
                this.columnwait = new DataColumn("wait", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnwait);
                this.columnCollectors_Id = new DataColumn("Collectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollectors_Id);
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columntype.Namespace = "";
                this.columntype.DefaultValue = "customutility";
                this.columnpoint.Namespace = "";
                this.columnpoint.DefaultValue = "startup";
                this.columncmd.Namespace = "";
                this.columncmd.DefaultValue = "";
                this.columngroupname.Namespace = "";
                this.columngroupname.DefaultValue = "";
                this.columntaskname.Namespace = "";
                this.columntaskname.DefaultValue = "";
                this.columncustomdiagtype.Namespace = "";
                this.columncustomdiagtype.DefaultValue = "utility";
                this.columnwait.Namespace = "";
                this.columnwait.DefaultValue = "no";
            }
            
            public CollectorRow NewCollectorRow() {
                return ((CollectorRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new CollectorRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(CollectorRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.CollectorRowChanged != null)) {
                    this.CollectorRowChanged(this, new CollectorRowChangeEvent(((CollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.CollectorRowChanging != null)) {
                    this.CollectorRowChanging(this, new CollectorRowChangeEvent(((CollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.CollectorRowDeleted != null)) {
                    this.CollectorRowDeleted(this, new CollectorRowChangeEvent(((CollectorRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.CollectorRowDeleting != null)) {
                    this.CollectorRowDeleting(this, new CollectorRowChangeEvent(((CollectorRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveCollectorRow(CollectorRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectorRow : DataRow {
            
            private CollectorDataTable tableCollector;
            
            internal CollectorRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableCollector = ((CollectorDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableCollector.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.enabledColumn] = value;
                }
            }
            
            public string type {
                get {
                    try {
                        return ((string)(this[this.tableCollector.typeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.typeColumn] = value;
                }
            }
            
            public string point {
                get {
                    try {
                        return ((string)(this[this.tableCollector.pointColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.pointColumn] = value;
                }
            }
            
            public string cmd {
                get {
                    try {
                        return ((string)(this[this.tableCollector.cmdColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.cmdColumn] = value;
                }
            }
            
            public string groupname {
                get {
                    try {
                        return ((string)(this[this.tableCollector.groupnameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.groupnameColumn] = value;
                }
            }
            
            public string taskname {
                get {
                    try {
                        return ((string)(this[this.tableCollector.tasknameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.tasknameColumn] = value;
                }
            }
            
            public string customdiagtype {
                get {
                    try {
                        return ((string)(this[this.tableCollector.customdiagtypeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.customdiagtypeColumn] = value;
                }
            }
            
            public string wait {
                get {
                    try {
                        return ((string)(this[this.tableCollector.waitColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCollector.waitColumn] = value;
                }
            }
            
            public CollectorsRow CollectorsRow {
                get {
                    return ((CollectorsRow)(this.GetParentRow(this.Table.ParentRelations["Collectors_Collector"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Collectors_Collector"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableCollector.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableCollector.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IstypeNull() {
                return this.IsNull(this.tableCollector.typeColumn);
            }
            
            public void SettypeNull() {
                this[this.tableCollector.typeColumn] = System.Convert.DBNull;
            }
            
            public bool IspointNull() {
                return this.IsNull(this.tableCollector.pointColumn);
            }
            
            public void SetpointNull() {
                this[this.tableCollector.pointColumn] = System.Convert.DBNull;
            }
            
            public bool IscmdNull() {
                return this.IsNull(this.tableCollector.cmdColumn);
            }
            
            public void SetcmdNull() {
                this[this.tableCollector.cmdColumn] = System.Convert.DBNull;
            }
            
            public bool IsgroupnameNull() {
                return this.IsNull(this.tableCollector.groupnameColumn);
            }
            
            public void SetgroupnameNull() {
                this[this.tableCollector.groupnameColumn] = System.Convert.DBNull;
            }
            
            public bool IstasknameNull() {
                return this.IsNull(this.tableCollector.tasknameColumn);
            }
            
            public void SettasknameNull() {
                this[this.tableCollector.tasknameColumn] = System.Convert.DBNull;
            }
            
            public bool IscustomdiagtypeNull() {
                return this.IsNull(this.tableCollector.customdiagtypeColumn);
            }
            
            public void SetcustomdiagtypeNull() {
                this[this.tableCollector.customdiagtypeColumn] = System.Convert.DBNull;
            }
            
            public bool IswaitNull() {
                return this.IsNull(this.tableCollector.waitColumn);
            }
            
            public void SetwaitNull() {
                this[this.tableCollector.waitColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CollectorRowChangeEvent : EventArgs {
            
            private CollectorRow eventRow;
            
            private DataRowAction eventAction;
            
            public CollectorRowChangeEvent(CollectorRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public CollectorRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CustomDiagGroupDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columnname;
            
            private DataColumn columnCollectors_Id;
            
            internal CustomDiagGroupDataTable() : 
                    base("CustomDiagGroup") {
                this.InitClass();
            }
            
            internal CustomDiagGroupDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn Collectors_IdColumn {
                get {
                    return this.columnCollectors_Id;
                }
            }
            
            public CustomDiagGroupRow this[int index] {
                get {
                    return ((CustomDiagGroupRow)(this.Rows[index]));
                }
            }
            
            public event CustomDiagGroupRowChangeEventHandler CustomDiagGroupRowChanged;
            
            public event CustomDiagGroupRowChangeEventHandler CustomDiagGroupRowChanging;
            
            public event CustomDiagGroupRowChangeEventHandler CustomDiagGroupRowDeleted;
            
            public event CustomDiagGroupRowChangeEventHandler CustomDiagGroupRowDeleting;
            
            public void AddCustomDiagGroupRow(CustomDiagGroupRow row) {
                this.Rows.Add(row);
            }
            
            public CustomDiagGroupRow AddCustomDiagGroupRow(bool enabled, string name, CollectorsRow parentCollectorsRowByCollectors_CustomDiagGroup) {
                CustomDiagGroupRow rowCustomDiagGroupRow = ((CustomDiagGroupRow)(this.NewRow()));
                rowCustomDiagGroupRow.ItemArray = new object[] {
                        enabled,
                        name,
                        parentCollectorsRowByCollectors_CustomDiagGroup[0]};
                this.Rows.Add(rowCustomDiagGroupRow);
                return rowCustomDiagGroupRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                CustomDiagGroupDataTable cln = ((CustomDiagGroupDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new CustomDiagGroupDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columnname = this.Columns["name"];
                this.columnCollectors_Id = this.Columns["Collectors_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columnCollectors_Id = new DataColumn("Collectors_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCollectors_Id);
                this.columnenabled.Namespace = "";
                this.columnenabled.DefaultValue = false;
                this.columnname.Namespace = "";
                this.columnname.DefaultValue = "";
            }
            
            public CustomDiagGroupRow NewCustomDiagGroupRow() {
                return ((CustomDiagGroupRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new CustomDiagGroupRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(CustomDiagGroupRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.CustomDiagGroupRowChanged != null)) {
                    this.CustomDiagGroupRowChanged(this, new CustomDiagGroupRowChangeEvent(((CustomDiagGroupRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.CustomDiagGroupRowChanging != null)) {
                    this.CustomDiagGroupRowChanging(this, new CustomDiagGroupRowChangeEvent(((CustomDiagGroupRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.CustomDiagGroupRowDeleted != null)) {
                    this.CustomDiagGroupRowDeleted(this, new CustomDiagGroupRowChangeEvent(((CustomDiagGroupRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.CustomDiagGroupRowDeleting != null)) {
                    this.CustomDiagGroupRowDeleting(this, new CustomDiagGroupRowChangeEvent(((CustomDiagGroupRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveCustomDiagGroupRow(CustomDiagGroupRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CustomDiagGroupRow : DataRow {
            
            private CustomDiagGroupDataTable tableCustomDiagGroup;
            
            internal CustomDiagGroupRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableCustomDiagGroup = ((CustomDiagGroupDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableCustomDiagGroup.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomDiagGroup.enabledColumn] = value;
                }
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tableCustomDiagGroup.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomDiagGroup.nameColumn] = value;
                }
            }
            
            public CollectorsRow CollectorsRow {
                get {
                    return ((CollectorsRow)(this.GetParentRow(this.Table.ParentRelations["Collectors_CustomDiagGroup"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["Collectors_CustomDiagGroup"]);
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableCustomDiagGroup.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableCustomDiagGroup.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tableCustomDiagGroup.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tableCustomDiagGroup.nameColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CustomDiagGroupRowChangeEvent : EventArgs {
            
            private CustomDiagGroupRow eventRow;
            
            private DataRowAction eventAction;
            
            public CustomDiagGroupRowChangeEvent(CustomDiagGroupRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public CustomDiagGroupRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
    }
}
